diff --git a/lib/puppet/metatype/manager.rb b/lib/puppet/metatype/manager.rb
index 865a7c296..34b2bdea7 100644
--- a/lib/puppet/metatype/manager.rb
+++ b/lib/puppet/metatype/manager.rb
@@ -1,141 +1,141 @@
 require 'puppet'
 require 'puppet/util/classgen'
 
 # Methods dealing with Type management.  This module gets included into the
 # Puppet::Type class, it's just split out here for clarity.
 module Puppet::MetaType
 module Manager
     include Puppet::Util::ClassGen
 
     # remove all type instances; this is mostly only useful for testing
     def allclear
         @types.each { |name, type|
             type.clear
         }
     end
 
     # iterate across all of the subclasses of Type
     def eachtype
         @types.each do |name, type|
             # Only consider types that have names
             #if ! type.parameters.empty? or ! type.validproperties.empty?
                 yield type
             #end
         end
     end
 
     # Load all types.  Only currently used for documentation.
     def loadall
         typeloader.loadall
     end
 
     # Define a new type.
     def newtype(name, options = {}, &block)
         # Handle backward compatibility
         unless options.is_a?(Hash)
             Puppet.warning "Puppet::Type.newtype(%s) now expects a hash as the second argument, not %s" % [name, options.inspect]
             options = {:parent => options}
         end
 
         # First make sure we don't have a method sitting around
         name = symbolize(name)
         newmethod = "new#{name.to_s}"
 
         # Used for method manipulation.
-        selfobj = metaclass()
+        selfobj = singleton_class()
 
         @types ||= {}
 
         if @types.include?(name)
             if self.respond_to?(newmethod)
                 # Remove the old newmethod
                 selfobj.send(:remove_method,newmethod)
             end
         end
 
         options = symbolize_options(options)
 
         if parent = options[:parent]
             options.delete(:parent)
         end
 
         # Then create the class.
         klass = genclass(name,
             :parent => (parent || Puppet::Type),
             :overwrite => true,
             :hash => @types,
             :attributes => options,
             &block
         )
 
         # Now define a "new<type>" method for convenience.
         if self.respond_to? newmethod
             # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
             Puppet.warning "'new#{name.to_s}' method already exists; skipping"
         else
             selfobj.send(:define_method, newmethod) do |*args|
                 klass.create(*args)
             end
         end
 
         # If they've got all the necessary methods defined and they haven't
         # already added the property, then do so now.
         if klass.ensurable? and ! klass.validproperty?(:ensure)
             klass.ensurable
         end
 
         # Now set up autoload any providers that might exist for this type.
         klass.providerloader = Puppet::Util::Autoload.new(klass,
             "puppet/provider/#{klass.name.to_s}"
         )
 
         # We have to load everything so that we can figure out the default type.
         klass.providerloader.loadall()
 
         klass
     end
 
     # Remove an existing defined type.  Largely used for testing.
     def rmtype(name)
         # Then create the class.
         klass = rmclass(name,
             :hash => @types
         )
 
         if respond_to?("new" + name.to_s)
-            metaclass.send(:remove_method, "new" + name.to_s)
+            singleton_class.send(:remove_method, "new" + name.to_s)
         end
     end
 
     # Return a Type instance by name.
     def type(name)
         @types ||= {}
 
         name = name.to_s.downcase.to_sym
 
         if t = @types[name]
             return t
         else
             if typeloader.load(name)
                 unless @types.include? name
                     Puppet.warning "Loaded puppet/type/#{name} but no class was created"
                 end
             end
 
             return @types[name]
         end
     end
 
     # Create a loader for Puppet types.
     def typeloader
         unless defined? @typeloader
             @typeloader = Puppet::Util::Autoload.new(self,
                 "puppet/type", :wrap => false
             )
         end
 
         @typeloader
     end
 end
 end
 
diff --git a/lib/puppet/network/xmlrpc/client.rb b/lib/puppet/network/xmlrpc/client.rb
index 9faa71c8b..f12d279d4 100644
--- a/lib/puppet/network/xmlrpc/client.rb
+++ b/lib/puppet/network/xmlrpc/client.rb
@@ -1,219 +1,219 @@
 require 'puppet/sslcertificates'
 require 'puppet/network/http_pool'
 require 'openssl'
 require 'puppet/external/base64'
 
 require 'xmlrpc/client'
 require 'net/https'
 require 'yaml'
 
 module Puppet::Network
     class ClientError < Puppet::Error; end
     class XMLRPCClientError < Puppet::Error; end
     class XMLRPCClient < ::XMLRPC::Client
 
         attr_accessor :puppet_server, :puppet_port
         @clients = {}
 
         class << self
             include Puppet::Util
             include Puppet::Util::ClassGen
         end
 
         # Create a netclient for each handler
         def self.mkclient(handler)
             interface = handler.interface
             namespace = interface.prefix
 
             # Create a subclass for every client type.  This is
             # so that all of the methods are on their own class,
             # so that their namespaces can define the same methods if
             # they want.
             constant = handler.name.to_s.capitalize
             name = namespace.downcase
             newclient = genclass(name, :hash => @clients, :constant => constant)
 
             interface.methods.each { |ary|
                 method = ary[0]
                 newclient.send(:define_method,method) { |*args|
                     make_rpc_call(namespace, method, *args)
                 }
             }
 
             return newclient
         end
 
         def self.handler_class(handler)
             @clients[handler] || self.mkclient(handler)
         end
 
         class ErrorHandler
             def initialize(&block)
-                metaclass.define_method(:execute, &block)
+                singleton_class.define_method(:execute, &block)
             end
         end
 
         # Use a class variable so all subclasses have access to it.
         @@error_handlers = {}
 
         def self.error_handler(exception)
             if handler = @@error_handlers[exception.class]
                 return handler
             else
                 return @@error_handlers[:default]
             end
         end
 
         def self.handle_error(*exceptions, &block)
             handler = ErrorHandler.new(&block)
 
             exceptions.each do |exception|
                 @@error_handlers[exception] = handler
             end
         end
 
         handle_error(OpenSSL::SSL::SSLError) do |client, detail, namespace, method|
             if detail.message =~ /bad write retry/
                 Puppet.warning "Transient SSL write error; restarting connection and retrying"
                 client.recycle_connection
                 return :retry
             end
             ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
                 if detail.message.include?(str)
                     Puppet.warning "Certificate validation failed; consider using the certname configuration option"
                 end
             end
             raise XMLRPCClientError, "Certificates were not trusted: %s" % detail
         end
 
         handle_error(:default) do |client, detail, namespace, method|
             if detail.message.to_s =~ /^Wrong size\. Was \d+, should be \d+$/
                 Puppet.warning "XMLRPC returned wrong size.  Retrying."
                 return :retry
             end
             Puppet.err "Could not call %s.%s: %s" % [namespace, method, detail.inspect]
             error = XMLRPCClientError.new(detail.to_s)
             error.set_backtrace detail.backtrace
             raise error
         end
 
         handle_error(OpenSSL::SSL::SSLError) do |client, detail, namespace, method|
             if detail.message =~ /bad write retry/
                 Puppet.warning "Transient SSL write error; restarting connection and retrying"
                 client.recycle_connection
                 return :retry
             end
             ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
                 if detail.message.include?(str)
                     Puppet.warning "Certificate validation failed; consider using the certname configuration option"
                 end
             end
             raise XMLRPCClientError, "Certificates were not trusted: %s" % detail
         end
 
         handle_error(::XMLRPC::FaultException) do |client, detail, namespace, method|
             raise XMLRPCClientError, detail.faultString
         end
 
         handle_error(Errno::ECONNREFUSED) do |client, detail, namespace, method|
             msg = "Could not connect to %s on port %s" % [client.host, client.port]
             raise XMLRPCClientError, msg
         end
 
         handle_error(SocketError) do |client, detail, namespace, method|
             Puppet.err "Could not find server %s: %s" % [@host, detail.to_s]
             error = XMLRPCClientError.new("Could not find server %s" % client.host)
             error.set_backtrace detail.backtrace
             raise error
         end
 
         handle_error(Errno::EPIPE, EOFError) do |client, detail, namespace, method|
             Puppet.info "Other end went away; restarting connection and retrying"
             client.recycle_connection
             return :retry
         end
 
         handle_error(Timeout::Error) do |client, detail, namespace, method|
             Puppet.err "Connection timeout calling %s.%s: %s" % [namespace, method, detail.to_s]
             error = XMLRPCClientError.new("Connection Timeout")
             error.set_backtrace(detail.backtrace)
             raise error
         end
 
         def make_rpc_call(namespace, method, *args)
             Puppet.debug "Calling %s.%s" % [namespace, method]
             begin
                 call("%s.%s" % [namespace, method.to_s],*args)
             rescue SystemExit,NoMemoryError
                 raise
             rescue Exception => detail
                 retry if self.class.error_handler(detail).execute(self, detail, namespace, method) == :retry
             end
         ensure
             http.finish if http.started?
         end
 
         def http
             unless @http
                 @http = Puppet::Network::HttpPool.http_instance(host, port, true)
             end
             @http
         end
 
         attr_reader :host, :port
 
         def initialize(hash = {})
             hash[:Path] ||= "/RPC2"
             hash[:Server] ||= Puppet[:server]
             hash[:Port] ||= Puppet[:masterport]
             hash[:HTTPProxyHost] ||= Puppet[:http_proxy_host]
             hash[:HTTPProxyPort] ||= Puppet[:http_proxy_port]
 
             if "none" == hash[:HTTPProxyHost]
                 hash[:HTTPProxyHost] = nil
                 hash[:HTTPProxyPort] = nil
             end
 
             super(
                 hash[:Server],
                 hash[:Path],
                 hash[:Port],
                 hash[:HTTPProxyHost],
                 hash[:HTTPProxyPort],
                 nil, # user
                 nil, # password
                 true, # use_ssl
                 Puppet[:configtimeout] # use configured timeout (#1176)
             )
             @http = Puppet::Network::HttpPool.http_instance(@host, @port)
         end
 
         # Get rid of our existing connection, replacing it with a new one.
         # This should only happen if we lose our connection somehow (e.g., an EPIPE)
         # or we've just downloaded certs and we need to create new http instances
         # with the certs added.
         def recycle_connection
             if http.started?
                 http.finish
             end
             @http = nil
             self.http # force a new one
         end
 
         def start
             begin
                 @http.start unless @http.started?
             rescue => detail
                 Puppet.err "Could not connect to server: %s" % detail
             end
         end
 
         def local
             false
         end
 
         def local?
             false
         end
     end
 end
diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb
index 58a91477a..2ebb74049 100644
--- a/lib/puppet/parameter.rb
+++ b/lib/puppet/parameter.rb
@@ -1,554 +1,554 @@
 require 'puppet/util/methodhelper'
 require 'puppet/util/log_paths'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
 require 'puppet/util/cacher'
 
 class Puppet::Parameter
     include Puppet::Util
     include Puppet::Util::Errors
     include Puppet::Util::LogPaths
     include Puppet::Util::Logging
     include Puppet::Util::MethodHelper
     include Puppet::Util::Cacher
 
     # A collection of values and regexes, used for specifying
     # what values are allowed in a given parameter.
     class ValueCollection
         class Value
             attr_reader :name, :options, :event
             attr_accessor :block, :call, :method, :required_features
 
             # Add an alias for this value.
             def alias(name)
                 @aliases << convert(name)
             end
 
             # Return all aliases.
             def aliases
                 @aliases.dup
             end
 
             # Store the event that our value generates, if it does so.
             def event=(value)
                 @event = convert(value)
             end
 
             def initialize(name)
                 if name.is_a?(Regexp)
                     @name = name
                 else
                     # Convert to a string and then a symbol, so things like true/false
                     # still show up as symbols.
                     @name = convert(name)
                 end
 
                 @aliases = []
 
                 @call = :instead
             end
 
             # Does a provided value match our value?
             def match?(value)
                 if regex?
                     return true if name =~ value.to_s
                 else
                     return true if name == convert(value)
                     return @aliases.include?(convert(value))
                 end
             end
 
             # Is our value a regex?
             def regex?
                 @name.is_a?(Regexp)
             end
 
             private
 
             # A standard way of converting all of our values, so we're always
             # comparing apples to apples.
             def convert(value)
                 if value == ''
                     # We can't intern an empty string, yay.
                     value
                 else
                     value.to_s.to_sym
                 end
             end
         end
 
         def aliasvalue(name, other)
             other = other.to_sym
             unless value = match?(other)
                 raise Puppet::DevError, "Cannot alias nonexistent value %s" % other
             end
 
             value.alias(name)
         end
 
         # Return a doc string for all of the values in this parameter/property.
         def doc
             unless defined?(@doc)
                 @doc = ""
                 unless values.empty?
                     @doc += "  Valid values are "
                     @doc += @strings.collect do |value|
                         if aliases = value.aliases and ! aliases.empty?
                             "``%s`` (also called ``%s``)" % [value.name, aliases.join(", ")]
                         else
                             "``%s``" % value.name
                         end
                     end.join(", ") + "."
                 end
 
                 unless regexes.empty?
                     @doc += "  Values can match ``" + regexes.join("``, ``") + "``."
                 end
             end
 
             @doc
         end
 
         # Does this collection contain any value definitions?
         def empty?
             @values.empty?
         end
 
         def initialize
             # We often look values up by name, so a hash makes more sense.
             @values = {}
 
             # However, we want to retain the ability to match values in order,
             # but we always prefer directly equality (i.e., strings) over regex matches.
             @regexes = []
             @strings = []
         end
 
         # Can we match a given value?
         def match?(test_value)
             # First look for normal values
             if value = @strings.find { |v| v.match?(test_value) }
                 return value
             end
 
             # Then look for a regex match
             @regexes.find { |v| v.match?(test_value) }
         end
 
         # If the specified value is allowed, then munge appropriately.
         def munge(value)
             return value if empty?
 
             if instance = match?(value)
                 if instance.regex?
                     return value
                 else
                     return instance.name
                 end
             else
                 return value
             end
         end
 
         # Define a new valid value for a property.  You must provide the value itself,
         # usually as a symbol, or a regex to match the value.
         #
         # The first argument to the method is either the value itself or a regex.
         # The second argument is an option hash; valid options are:
         # * <tt>:event</tt>: The event that should be returned when this value is set.
         # * <tt>:call</tt>: When to call any associated block.  The default value
         #   is ``instead``, which means to call the value instead of calling the
         #   provider.  You can also specify ``before`` or ``after``, which will
         #   call both the block and the provider, according to the order you specify
         #   (the ``first`` refers to when the block is called, not the provider).
         def newvalue(name, options = {}, &block)
             value = Value.new(name)
             @values[value.name] = value
             if value.regex?
                 @regexes << value
             else
                 @strings << value
             end
 
             options.each { |opt, arg| value.send(opt.to_s + "=", arg) }
             if block_given?
                 value.block = block
             else
                 value.call = options[:call] || :none
             end
 
             if block_given? and ! value.regex?
                 value.method ||= "set_" + value.name.to_s
             end
 
             value
         end
 
         # Define one or more new values for our parameter.
         def newvalues(*names)
             names.each { |name| newvalue(name) }
         end
 
         def regexes
             @regexes.collect { |r| r.name.inspect }
         end
 
         # Verify that the passed value is valid.
         def validate(value)
             return if empty?
 
             unless @values.detect { |name, v| v.match?(value) }
                 str = "Invalid value %s. " % [value.inspect]
 
                 unless values.empty?
                     str += "Valid values are %s. " % values.join(", ")
                 end
 
                 unless regexes.empty?
                     str += "Valid values match %s." % regexes.join(", ")
                 end
 
                 raise ArgumentError, str
             end
         end
 
         # Return a single value instance.
         def value(name)
             @values[name]
         end
 
         # Return the list of valid values.
         def values
             @strings.collect { |s| s.name }
         end
     end
 
     class << self
         include Puppet::Util
         include Puppet::Util::Docs
         attr_reader :validater, :munger, :name, :default, :required_features, :value_collection
         attr_accessor :metaparam
 
         # Define the default value for a given parameter or parameter.  This
         # means that 'nil' is an invalid default value.  This defines
         # the 'default' instance method.
         def defaultto(value = nil, &block)
             if block
                 define_method(:default, &block)
             else
                 if value.nil?
                     raise Puppet::DevError,
                         "Either a default value or block must be provided"
                 end
                 define_method(:default) do value end
             end
         end
 
         # Return a documentation string.  If there are valid values,
         # then tack them onto the string.
         def doc
             @doc ||= ""
 
             unless defined? @addeddocvals
                 @doc += value_collection.doc
 
                 if f = self.required_features
                     @doc += "  Requires features %s." % f.flatten.collect { |f| f.to_s }.join(" ")
                 end
                 @addeddocvals = true
             end
 
             @doc
         end
 
         def nodefault
             if public_method_defined? :default
                 undef_method :default
             end
         end
 
         # Store documentation for this parameter.
         def desc(str)
             @doc = str
         end
 
         def initvars
             @value_collection = ValueCollection.new
         end
 
         # This is how we munge the value.  Basically, this is our
         # opportunity to convert the value from one form into another.
         def munge(&block)
             # I need to wrap the unsafe version in begin/rescue parameterments,
             # but if I directly call the block then it gets bound to the
             # class's context, not the instance's, thus the two methods,
             # instead of just one.
             define_method(:unsafe_munge, &block)
         end
 
         # Does the parameter supports reverse munge?
         # This will be called when something wants to access the parameter
         # in a canonical form different to what the storage form is.
         def unmunge(&block)
             define_method(:unmunge, &block)
         end
 
         # Optionaly convert the value to a canonical form so that it will
         # be found in hashes, etc.  Mostly useful for namevars.
         def to_canonicalize(&block)
-            metaclass = (class << self; self; end)
-            metaclass.send(:define_method,:canonicalize,&block)
+            singleton_class = (class << self; self; end)
+            singleton_class.send(:define_method,:canonicalize,&block)
         end
 
         # Mark whether we're the namevar.
         def isnamevar
             @isnamevar = true
             @required = true
         end
 
         # Is this parameter the namevar?  Defaults to false.
         def isnamevar?
             if defined? @isnamevar
                 return @isnamevar
             else
                 return false
             end
         end
 
         # This parameter is required.
         def isrequired
             @required = true
         end
 
         # Specify features that are required for this parameter to work.
         def required_features=(*args)
             @required_features = args.flatten.collect { |a| a.to_s.downcase.intern }
         end
 
         # Is this parameter required?  Defaults to false.
         def required?
             if defined? @required
                 return @required
             else
                 return false
             end
         end
 
         # Verify that we got a good value
         def validate(&block)
             define_method(:unsafe_validate, &block)
         end
 
         # Define a new value for our parameter.
         def newvalues(*names)
             @value_collection.newvalues(*names)
         end
 
         def aliasvalue(name, other)
             @value_collection.aliasvalue(name, other)
         end
     end
 
     # Just a simple method to proxy instance methods to class methods
     def self.proxymethods(*values)
         values.each { |val|
             define_method(val) do
                 self.class.send(val)
             end
         }
     end
 
     # And then define one of these proxies for each method in our
     # ParamHandler class.
     proxymethods("required?", "isnamevar?")
 
     attr_accessor :resource
     # LAK 2007-05-09: Keep the @parent around for backward compatibility.
     attr_accessor :parent
 
     [:line, :file, :version].each do |param|
         define_method(param) do
             resource.send(param)
         end
     end
 
     def devfail(msg)
         self.fail(Puppet::DevError, msg)
     end
 
     def expirer
         resource.catalog
     end
 
     def fail(*args)
         type = nil
         if args[0].is_a?(Class)
             type = args.shift
         else
             type = Puppet::Error
         end
 
         error = type.new(args.join(" "))
 
         if defined? @resource and @resource and @resource.line
             error.line = @resource.line
         end
 
         if defined? @resource and @resource and @resource.file
             error.file = @resource.file
         end
 
         raise error
     end
 
     # Basic parameter initialization.
     def initialize(options = {})
         options = symbolize_options(options)
         if resource = options[:resource]
             self.resource = resource
             options.delete(:resource)
         else
             raise Puppet::DevError, "No resource set for %s" % self.class.name
         end
 
         set_options(options)
     end
 
     # Log a message using the resource's log level.
     def log(msg)
         unless @resource[:loglevel]
             self.devfail "Parent %s has no loglevel" %
                 @resource.name
         end
         Puppet::Util::Log.create(
             :level => @resource[:loglevel],
             :message => msg,
             :source => self
         )
     end
 
     # Is this parameter a metaparam?
     def metaparam?
         self.class.metaparam
     end
 
     # each parameter class must define the name() method, and parameter
     # instances do not change that name this implicitly means that a given
     # object can only have one parameter instance of a given parameter
     # class
     def name
         return self.class.name
     end
 
     # for testing whether we should actually do anything
     def noop
         unless defined? @noop
             @noop = false
         end
         tmp = @noop || self.resource.noop || Puppet[:noop] || false
         #debug "noop is %s" % tmp
         return tmp
     end
 
     # return the full path to us, for logging and rollback; not currently
     # used
     def pathbuilder
         if defined? @resource and @resource
             return [@resource.pathbuilder, self.name]
         else
             return [self.name]
         end
     end
 
     # If the specified value is allowed, then munge appropriately.
     # If the developer uses a 'munge' hook, this method will get overridden.
     def unsafe_munge(value)
         self.class.value_collection.munge(value)
     end
 
     # no unmunge by default
     def unmunge(value)
         value
     end
 
     # Assume the value is already in canonical form by default
     def self.canonicalize(value)
         value
     end
 
     def canonicalize(value)
         self.class.canonicalize(value)
     end
 
     # A wrapper around our munging that makes sure we raise useful exceptions.
     def munge(value)
         begin
             ret = unsafe_munge(canonicalize(value))
         rescue Puppet::Error => detail
             Puppet.debug "Reraising %s" % detail
             raise
         rescue => detail
             raise Puppet::DevError, "Munging failed for value %s in class %s: %s" % [value.inspect, self.name, detail], detail.backtrace
         end
         ret
     end
 
     # Verify that the passed value is valid.
     # If the developer uses a 'validate' hook, this method will get overridden.
     def unsafe_validate(value)
         self.class.value_collection.validate(value)
     end
 
     # A protected validation method that only ever raises useful exceptions.
     def validate(value)
         begin
             unsafe_validate(value)
         rescue ArgumentError => detail
             fail detail.to_s
         rescue Puppet::Error, TypeError
             raise
         rescue => detail
             raise Puppet::DevError, "Validate method failed for class %s: %s" % [self.name, detail], detail.backtrace
         end
     end
 
     def remove
         @resource = nil
     end
 
     def value
         unmunge(@value)
     end
 
     # Store the value provided.  All of the checking should possibly be
     # late-binding (e.g., users might not exist when the value is assigned
     # but might when it is asked for).
     def value=(value)
         validate(value)
 
         @value = munge(value)
     end
 
     # Retrieve the resource's provider.  Some types don't have providers, in which
     # case we return the resource object itself.
     def provider
         @resource.provider
     end
 
     # The properties need to return tags so that logs correctly collect them.
     def tags
         unless defined? @tags
             @tags = []
             # This might not be true in testing
             if @resource.respond_to? :tags
                 @tags = @resource.tags
             end
             @tags << self.name.to_s
         end
         @tags
     end
 
     def to_s
         s = "Parameter(%s)" % self.name
     end
 end
diff --git a/lib/puppet/provider.rb b/lib/puppet/provider.rb
index 3cef0dd71..26279260a 100644
--- a/lib/puppet/provider.rb
+++ b/lib/puppet/provider.rb
@@ -1,293 +1,293 @@
 # The container class for implementations.
 class Puppet::Provider
     include Puppet::Util
     include Puppet::Util::Errors
     include Puppet::Util::Warnings
     extend Puppet::Util::Warnings
 
     require 'puppet/provider/confiner'
 
     extend Puppet::Provider::Confiner
 
     Puppet::Util.logmethods(self, true)
 
     class << self
         # Include the util module so we have access to things like 'binary'
         include Puppet::Util, Puppet::Util::Docs
         include Puppet::Util::Logging
         attr_accessor :name
 
         # The source parameter exists so that providers using the same
         # source can specify this, so reading doesn't attempt to read the
         # same package multiple times.
         attr_writer :source
 
         # LAK 2007-05-09: Keep the model stuff around for backward compatibility
         attr_reader :model
         attr_accessor :resource_type
         attr_writer :doc
     end
 
     # LAK 2007-05-09: Keep the model stuff around for backward compatibility
     attr_reader :model
     attr_accessor :resource
 
     def self.command(name)
         name = symbolize(name)
 
         if defined?(@commands) and command = @commands[name]
             # nothing
         elsif superclass.respond_to? :command and command = superclass.command(name)
             # nothing
         else
             raise Puppet::DevError, "No command %s defined for provider %s" %
                 [name, self.name]
         end
 
         return binary(command)
     end
 
     # Define commands that are not optional.
     def self.commands(hash)
         optional_commands(hash) do |name, path|
             confine :exists => path, :for_binary => true
         end
     end
 
     # Is the provided feature a declared feature?
     def self.declared_feature?(name)
         defined?(@declared_features) and @declared_features.include?(name)
     end
 
     # Does this implementation match all of the default requirements?  If
     # defaults are empty, we return false.
     def self.default?
         return false if @defaults.empty?
         if @defaults.find do |fact, values|
                 values = [values] unless values.is_a? Array
                 if fval = Facter.value(fact).to_s and fval != ""
                     fval = fval.to_s.downcase.intern
                 else
                     return false
                 end
 
                 # If any of the values match, we're a default.
                 if values.find do |value| fval == value.to_s.downcase.intern end
                     false
                 else
                     true
                 end
             end
             return false
         else
             return true
         end
     end
 
     # Store how to determine defaults.
     def self.defaultfor(hash)
         hash.each do |d,v|
             @defaults[d] = v
         end
     end
 
     def self.specificity
         (@defaults.length * 100) + ancestors.select { |a| a.is_a? Class }.length
     end
 
     def self.initvars
         @defaults = {}
         @commands = {}
     end
 
     # The method for returning a list of provider instances.  Note that it returns providers, preferably with values already
     # filled in, not resources.
     def self.instances
         raise Puppet::DevError, "Provider %s has not defined the 'instances' class method" % self.name
     end
 
     # Create the methods for a given command.
     def self.make_command_methods(name)
         # Now define a method for that command
-        unless metaclass.method_defined? name
+        unless singleton_class.method_defined? name
             meta_def(name) do |*args|
                 unless command(name)
                     raise Puppet::Error, "Command %s is missing" % name
                 end
                 if args.empty?
                     cmd = [command(name)]
                 else
                     cmd = [command(name)] + args
                 end
                 # This might throw an ExecutionFailure, but the system above
                 # will catch it, if so.
                 return execute(cmd)
             end
 
             # And then define an instance method that just calls the class method.
             # We need both, so both instances and classes can easily run the commands.
             unless method_defined? name
                 define_method(name) do |*args|
                     self.class.send(name, *args)
                 end
             end
         end
     end
 
     # Create getter/setter methods for each property our resource type supports.
     # They all get stored in @property_hash.  This method is useful
     # for those providers that use prefetch and flush.
     def self.mkmodelmethods
         warnonce "Provider.mkmodelmethods is deprecated; use Provider.mk_resource_methods"
         mk_resource_methods
     end
 
     # Create getter/setter methods for each property our resource type supports.
     # They all get stored in @property_hash.  This method is useful
     # for those providers that use prefetch and flush.
     def self.mk_resource_methods
         [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
             attr = symbolize(attr)
             next if attr == :name
             define_method(attr) do
                 @property_hash[attr] || :absent
             end
 
             define_method(attr.to_s + "=") do |val|
                 @property_hash[attr] = val
             end
         end
     end
 
     self.initvars
 
     # Define one or more binaries we'll be using.  If a block is passed, yield the name
     # and path to the block (really only used by 'commands').
     def self.optional_commands(hash)
         hash.each do |name, path|
             name = symbolize(name)
             @commands[name] = path
 
             if block_given?
                 yield(name, path)
             end
 
             # Now define the class and instance methods.
             make_command_methods(name)
         end
     end
 
     # Retrieve the data source.  Defaults to the provider name.
     def self.source
         unless defined? @source
             @source = self.name
         end
         @source
     end
 
     # Does this provider support the specified parameter?
     def self.supports_parameter?(param)
         if param.is_a?(Class)
             klass = param
         else
             unless klass = resource_type.attrclass(param)
                 raise Puppet::DevError, "'%s' is not a valid parameter for %s" % [param, resource_type.name]
             end
         end
         return true unless features = klass.required_features
 
         if satisfies?(*features)
             return true
         else
             return false
         end
     end
 
 #    def self.to_s
 #        unless defined? @str
 #            if self.resource_type
 #                @str = "%s provider %s" % [resource_type.name, self.name]
 #            else
 #                @str = "unattached provider %s" % [self.name]
 #            end
 #        end
 #        @str
 #    end
 
     dochook(:defaults) do
         if @defaults.length > 0
             return "  Default for " + @defaults.collect do |f, v|
                 "``#{f}`` == ``#{v}``"
             end.join(" and ") + "."
         end
     end
 
     dochook(:commands) do
         if @commands.length > 0
             return "  Required binaries: " + @commands.collect do |n, c|
                 "``#{c}``"
             end.join(", ") + "."
         end
     end
 
     dochook(:features) do
         if features().length > 0
             return "  Supported features: " + features().collect do |f|
                 "``#{f}``"
             end.join(", ") + "."
         end
     end
 
     # Remove the reference to the resource, so GC can clean up.
     def clear
         @resource = nil
         @model = nil
     end
 
     # Retrieve a named command.
     def command(name)
         self.class.command(name)
     end
 
     # Get a parameter value.
     def get(param)
         @property_hash[symbolize(param)] || :absent
     end
 
     def initialize(resource = nil)
         if resource.is_a?(Hash)
             # We don't use a duplicate here, because some providers (ParsedFile, at least)
             # use the hash here for later events.
             @property_hash = resource
         elsif resource
             @resource = resource
             # LAK 2007-05-09: Keep the model stuff around for backward compatibility
             @model = resource
             @property_hash = {}
         else
             @property_hash = {}
         end
     end
 
     def name
         if n = @property_hash[:name]
             return n
         elsif self.resource
             resource.name
         else
             raise Puppet::DevError, "No resource and no name in property hash in %s instance" % self.class.name
         end
     end
 
     # Set passed params as the current values.
     def set(params)
         params.each do |param, value|
             @property_hash[symbolize(param)] = value
         end
     end
 
     def to_s
         "%s(provider=%s)" % [@resource.to_s, self.class.name]
     end
 end
 
diff --git a/lib/puppet/provider/nameservice/directoryservice.rb b/lib/puppet/provider/nameservice/directoryservice.rb
index 50c87fe3e..9a4424dbb 100644
--- a/lib/puppet/provider/nameservice/directoryservice.rb
+++ b/lib/puppet/provider/nameservice/directoryservice.rb
@@ -1,532 +1,532 @@
 #  Created by Jeff McCune on 2007-07-22
 #  Copyright (c) 2007. All rights reserved.
 #
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
 # as published by the Free Software Foundation (version 2 of the License)
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston MA  02110-1301 USA
 
 require 'puppet'
 require 'puppet/provider/nameservice'
 require 'facter/util/plist'
 require 'cgi'
 
 
 class Puppet::Provider::NameService
 class DirectoryService < Puppet::Provider::NameService
-    # JJM: Dive into the eigenclass
+    # JJM: Dive into the singleton_class
     class << self
         # JJM: This allows us to pass information when calling
         #      Puppet::Type.type
         #  e.g. Puppet::Type.type(:user).provide :directoryservice, :ds_path => "Users"
         #  This is referenced in the get_ds_path class method
         attr_writer :ds_path
         attr_writer :macosx_version_major
     end
 
     initvars()
 
     commands :dscl => "/usr/bin/dscl"
     commands :dseditgroup => "/usr/sbin/dseditgroup"
     commands :sw_vers => "/usr/bin/sw_vers"
     confine :operatingsystem => :darwin
     defaultfor :operatingsystem => :darwin
 
 
     # JJM 2007-07-25: This map is used to map NameService attributes to their
     #     corresponding DirectoryService attribute names.
     #     See: http://images.apple.com/server/docs/Open_Directory_v10.4.pdf
     # JJM: Note, this is de-coupled from the Puppet::Type, and must
     #     be actively maintained.  There may also be collisions with different
     #     types (Users, Groups, Mounts, Hosts, etc...)
     @@ds_to_ns_attribute_map = {
         'RecordName' => :name,
         'PrimaryGroupID' => :gid,
         'NFSHomeDirectory' => :home,
         'UserShell' => :shell,
         'UniqueID' => :uid,
         'RealName' => :comment,
         'Password' => :password,
         'GeneratedUID' => :guid,
         'IPAddress'    => :ip_address,
         'ENetAddress'  => :en_address,
         'GroupMembership' => :members,
     }
     # JJM The same table as above, inverted.
     @@ns_to_ds_attribute_map = {
         :name => 'RecordName',
         :gid => 'PrimaryGroupID',
         :home => 'NFSHomeDirectory',
         :shell => 'UserShell',
         :uid => 'UniqueID',
         :comment => 'RealName',
         :password => 'Password',
         :guid => 'GeneratedUID',
         :en_address => 'ENetAddress',
         :ip_address => 'IPAddress',
         :members => 'GroupMembership',
     }
 
     @@password_hash_dir = "/var/db/shadow/hash"
 
     def self.instances
         # JJM Class method that provides an array of instance objects of this
         #     type.
         # JJM: Properties are dependent on the Puppet::Type we're managine.
         type_property_array = [:name] + @resource_type.validproperties
 
         # Create a new instance of this Puppet::Type for each object present
         #    on the system.
         list_all_present.collect do |name_string|
             self.new(single_report(name_string, *type_property_array))
         end
     end
 
     def self.get_ds_path
         # JJM: 2007-07-24 This method dynamically returns the DS path we're concerned with.
         #      For example, if we're working with an user type, this will be /Users
         #      with a group type, this will be /Groups.
         #   @ds_path is an attribute of the class itself.
         if defined? @ds_path
             return @ds_path
         end
         # JJM: "Users" or "Groups" etc ...  (Based on the Puppet::Type)
         #       Remember this is a class method, so self.class is Class
         #       Also, @resource_type seems to be the reference to the
         #       Puppet::Type this class object is providing for.
         return @resource_type.name.to_s.capitalize + "s"
     end
 
     def self.get_macosx_version_major
         if defined? @macosx_version_major
             return @macosx_version_major
         end
         begin
             # Make sure we've loaded all of the facts
             Facter.loadfacts
 
             if Facter.value(:macosx_productversion_major)
                 product_version_major = Facter.value(:macosx_productversion_major)
             else
                 # TODO: remove this code chunk once we require Facter 1.5.5 or higher.
                 Puppet.warning("DEPRECATION WARNING: Future versions of the directoryservice provider will require Facter 1.5.5 or newer.")            
                 product_version = Facter.value(:macosx_productversion)
                 if product_version.nil?
                     fail("Could not determine OS X version from Facter")
                 end
                 product_version_major = product_version.scan(/(\d+)\.(\d+)./).join(".")
             end
             if %w{10.0 10.1 10.2 10.3}.include?(product_version_major)
                 fail("%s is not supported by the directoryservice provider" % product_version_major)
             end
             @macosx_version_major = product_version_major
             return @macosx_version_major
         rescue Puppet::ExecutionFailure => detail
             fail("Could not determine OS X version: %s" % detail)
         end
     end
 
 
     def self.list_all_present
         # JJM: List all objects of this Puppet::Type already present on the system.
         begin
             dscl_output = execute(get_exec_preamble("-list"))
         rescue Puppet::ExecutionFailure => detail
            fail("Could not get %s list from DirectoryService" % [ @resource_type.name.to_s ])
         end
         return dscl_output.split("\n")
     end
 
     def self.parse_dscl_url_data(dscl_output)
         # we need to construct a Hash from the dscl -url output to match
         # that returned by the dscl -plist output for 10.5+ clients.
         #
         # Nasty assumptions:
         #   a) no values *end* in a colon ':', only keys
         #   b) if a line ends in a colon and the next line does start with
         #      a space, then the second line is a value of the first.
         #   c) (implied by (b)) keys don't start with spaces.
 
         dscl_plist = {}
         dscl_output.split("\n").inject([]) do |array, line|
           if line =~ /^\s+/   # it's a value
             array[-1] << line # add the value to the previous key
           else
             array << line
           end
           array
         end.compact
 
         dscl_output.each do |line|
             # This should be a 'normal' entry. key and value on one line.
             # We split on ': ' to deal with keys/values with a colon in them.
             split_array = line.split(/:\s+/)
             key = split_array.first
             value = CGI::unescape(split_array.last.strip.chomp)
             # We need to treat GroupMembership separately as it is currently
             # the only attribute we care about multiple values for, and
             # the values can never contain spaces (shortnames)
             # We also make every value an array to be consistent with the
             # output of dscl -plist under 10.5
             if key == "GroupMembership"
                 dscl_plist[key] = value.split(/\s/)
             else
                 dscl_plist[key] = [value]
             end
         end
         return dscl_plist
     end
 
     def self.parse_dscl_plist_data(dscl_output)
         return Plist.parse_xml(dscl_output)
     end
 
     def self.generate_attribute_hash(input_hash, *type_properties)
         attribute_hash = {}
         input_hash.keys().each do |key|
             ds_attribute = key.sub("dsAttrTypeStandard:", "")
             next unless (@@ds_to_ns_attribute_map.keys.include?(ds_attribute) and type_properties.include? @@ds_to_ns_attribute_map[ds_attribute])
             ds_value = input_hash[key]
             case @@ds_to_ns_attribute_map[ds_attribute]
                 when :members
                     ds_value = ds_value # only members uses arrays so far
                 when :gid, :uid
                     # OS X stores objects like uid/gid as strings.
                     # Try casting to an integer for these cases to be
                     # consistent with the other providers and the group type
                     # validation
                     begin
                         ds_value = Integer(ds_value[0])
                     rescue ArgumentError
                         ds_value = ds_value[0]
                     end
                 else ds_value = ds_value[0]
             end
             attribute_hash[@@ds_to_ns_attribute_map[ds_attribute]] = ds_value
         end
 
         # NBK: need to read the existing password here as it's not actually
         # stored in the user record. It is stored at a path that involves the
         # UUID of the user record for non-Mobile local acccounts.
         # Mobile Accounts are out of scope for this provider for now
         if @resource_type.validproperties.include?(:password)
             attribute_hash[:password] = self.get_password(attribute_hash[:guid])
         end
         return attribute_hash
     end
 
     def self.single_report(resource_name, *type_properties)
         # JJM 2007-07-24:
         #     Given a the name of an object and a list of properties of that
         #     object, return all property values in a hash.
         #
         #     This class method returns nil if the object doesn't exist
         #     Otherwise, it returns a hash of the object properties.
 
         all_present_str_array = list_all_present()
 
         # NBK: shortcut the process if the resource is missing
         return nil unless all_present_str_array.include? resource_name
 
         dscl_vector = get_exec_preamble("-read", resource_name)
         begin
             dscl_output = execute(dscl_vector)
         rescue Puppet::ExecutionFailure => detail
             fail("Could not get report.  command execution failed.")
         end
 
         # Two code paths is ugly, but until we can drop 10.4 support we don't
         # have a lot of choice. Ultimately this should all be done using Ruby
         # to access the DirectoryService APIs directly, but that's simply not
         # feasible for a while yet.
         case self.get_macosx_version_major
         when "10.4"
             dscl_plist = self.parse_dscl_url_data(dscl_output)
         when "10.5", "10.6"
             dscl_plist = self.parse_dscl_plist_data(dscl_output)
         end
 
         return self.generate_attribute_hash(dscl_plist, *type_properties)
     end
 
     def self.get_exec_preamble(ds_action, resource_name = nil)
         # JJM 2007-07-24
         #     DSCL commands are often repetitive and contain the same positional
         #     arguments over and over. See http://developer.apple.com/documentation/Porting/Conceptual/PortingUnix/additionalfeatures/chapter_10_section_9.html
         #     for an example of what I mean.
         #     This method spits out proper DSCL commands for us.
         #     We EXPECT name to be @resource[:name] when called from an instance object.
 
         # 10.4 doesn't support the -plist option for dscl, and 10.5 has a
         # different format for the -url output with objects with spaces in
         # their values. *sigh*. Use -url for 10.4 in the hope this can be
         # deprecated one day, and use -plist for 10.5 and higher.
         case self.get_macosx_version_major
         when "10.4"
             command_vector = [ command(:dscl), "-url", "." ]
         when "10.5", "10.6"
             command_vector = [ command(:dscl), "-plist", "." ]
         end
         # JJM: The actual action to perform.  See "man dscl"
         #      Common actiosn: -create, -delete, -merge, -append, -passwd
         command_vector << ds_action
         # JJM: get_ds_path will spit back "Users" or "Groups",
         # etc...  Depending on the Puppet::Type of our self.
         if resource_name
             command_vector << "/%s/%s" % [ get_ds_path, resource_name ]
         else
             command_vector << "/%s" % [ get_ds_path ]
         end
         # JJM:  This returns most of the preamble of the command.
         #       e.g. 'dscl / -create /Users/mccune'
         return command_vector
     end
 
     def self.set_password(resource_name, guid, password_hash)
         password_hash_file = "#{@@password_hash_dir}/#{guid}"
         begin
             File.open(password_hash_file, 'w') { |f| f.write(password_hash)}
         rescue Errno::EACCES => detail
             fail("Could not write to password hash file: #{detail}")
         end
 
         # NBK: For shadow hashes, the user AuthenticationAuthority must contain a value of
         # ";ShadowHash;". The LKDC in 10.5 makes this more interesting though as it
         # will dynamically generate ;Kerberosv5;;username@LKDC:SHA1 attributes if
         # missing. Thus we make sure we only set ;ShadowHash; if it is missing, and
         # we can do this with the merge command. This allows people to continue to
         # use other custom AuthenticationAuthority attributes without stomping on them.
         #
         # There is a potential problem here in that we're only doing this when setting
         # the password, and the attribute could get modified at other times while the
         # hash doesn't change and so this doesn't get called at all... but
         # without switching all the other attributes to merge instead of create I can't
         # see a simple enough solution for this that doesn't modify the user record
         # every single time. This should be a rather rare edge case. (famous last words)
 
         dscl_vector = self.get_exec_preamble("-merge", resource_name)
         dscl_vector << "AuthenticationAuthority" << ";ShadowHash;"
         begin
             dscl_output = execute(dscl_vector)
         rescue Puppet::ExecutionFailure => detail
             fail("Could not set AuthenticationAuthority.")
         end
     end
 
     def self.get_password(guid)
         password_hash = nil
         password_hash_file = "#{@@password_hash_dir}/#{guid}"
         if File.exists?(password_hash_file) and File.file?(password_hash_file)
             if not File.readable?(password_hash_file)
                 fail("Could not read password hash file at #{password_hash_file} for #{@resource[:name]}")
             end
             f = File.new(password_hash_file)
             password_hash = f.read
             f.close
         end
         password_hash
     end
 
     def ensure=(ensure_value)
         super
         # We need to loop over all valid properties for the type we're
         # managing and call the method which sets that property value
         # dscl can't create everything at once unfortunately.
         if ensure_value == :present
             @resource.class.validproperties.each do |name|
                 next if name == :ensure
                 # LAK: We use property.sync here rather than directly calling
                 # the settor method because the properties might do some kind
                 # of conversion.  In particular, the user gid property might
                 # have a string and need to convert it to a number
                 if @resource.should(name)
                     @resource.property(name).sync
                 elsif value = autogen(name)
                     self.send(name.to_s + "=", value)
                 else
                     next
                 end
             end
         end
     end
 
     def password=(passphrase)
       exec_arg_vector = self.class.get_exec_preamble("-read", @resource.name)
       exec_arg_vector << @@ns_to_ds_attribute_map[:guid]
       begin
           guid_output = execute(exec_arg_vector)
           guid_plist = Plist.parse_xml(guid_output)
           # Although GeneratedUID like all DirectoryService values can be multi-valued
           # according to the schema, in practice user accounts cannot have multiple UUIDs
           # otherwise Bad Things Happen, so we just deal with the first value.
           guid = guid_plist["dsAttrTypeStandard:#{@@ns_to_ds_attribute_map[:guid]}"][0]
           self.class.set_password(@resource.name, guid, passphrase)
       rescue Puppet::ExecutionFailure => detail
           fail("Could not set %s on %s[%s]: %s" % [param, @resource.class.name, @resource.name, detail])
       end
     end
 
     # NBK: we override @parent.set as we need to execute a series of commands
     # to deal with array values, rather than the single command nameservice.rb
     # expects to be returned by modifycmd. Thus we don't bother defining modifycmd.
 
     def set(param, value)
         self.class.validate(param, value)
         current_members = @property_value_cache_hash[:members]
         if param == :members
             # If we are meant to be authoritative for the group membership
             # then remove all existing members who haven't been specified
             # in the manifest.
             if @resource[:auth_membership] and not current_members.nil?
                 remove_unwanted_members(current_members, value)
              end
 
              # if they're not a member, make them one.
              add_members(current_members, value)
         else
             exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
             # JJM: The following line just maps the NS name to the DS name
             #      e.g. { :uid => 'UniqueID' }
             exec_arg_vector << @@ns_to_ds_attribute_map[symbolize(param)]
             # JJM: The following line sends the actual value to set the property to
             exec_arg_vector << value.to_s
             begin
                 execute(exec_arg_vector)
             rescue Puppet::ExecutionFailure => detail
                 fail("Could not set %s on %s[%s]: %s" % [param, @resource.class.name, @resource.name, detail])
             end
         end
     end
 
     # NBK: we override @parent.create as we need to execute a series of commands
     # to create objects with dscl, rather than the single command nameservice.rb
     # expects to be returned by addcmd. Thus we don't bother defining addcmd.
     def create
         if exists?
             info "already exists"
             return nil
         end
 
         # NBK: First we create the object with a known guid so we can set the contents
         # of the password hash if required
         # Shelling out sucks, but for a single use case it doesn't seem worth
         # requiring people install a UUID library that doesn't come with the system.
         # This should be revisited if Puppet starts managing UUIDs for other platform
         # user records.
         guid = %x{/usr/bin/uuidgen}.chomp
 
         exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
         exec_arg_vector << @@ns_to_ds_attribute_map[:guid] << guid
         begin
           execute(exec_arg_vector)
         rescue Puppet::ExecutionFailure => detail
             fail("Could not set GeneratedUID for %s %s: %s" %
                 [@resource.class.name, @resource.name, detail])
         end
 
         if value = @resource.should(:password) and value != ""
           self.class.set_password(@resource[:name], guid, value)
         end
 
         # Now we create all the standard properties
         Puppet::Type.type(@resource.class.name).validproperties.each do |property|
             next if property == :ensure
             if value = @resource.should(property) and value != ""
                 if property == :members
                     add_members(nil, value)
                 else
                     exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
                     exec_arg_vector << @@ns_to_ds_attribute_map[symbolize(property)]
                     next if property == :password  # skip setting the password here
                     exec_arg_vector << value.to_s
                     begin
                       execute(exec_arg_vector)
                     rescue Puppet::ExecutionFailure => detail
                         fail("Could not create %s %s: %s" %
                             [@resource.class.name, @resource.name, detail])
                     end
                 end
             end
         end
     end
 
     def remove_unwanted_members(current_members, new_members)
         current_members.each do |member|
             if not new_members.include?(member)
                 cmd = [:dseditgroup, "-o", "edit", "-n", ".", "-d", member, @resource[:name]]
                 begin
                      execute(cmd)
                 rescue Puppet::ExecutionFailure => detail
                      fail("Could not remove %s from group: %s, %s" % [member, @resource.name, detail])
                 end
              end
          end
     end
 
     def add_members(current_members, new_members)
         new_members.each do |new_member|
            if current_members.nil? or not current_members.include?(new_member)
                cmd = [:dseditgroup, "-o", "edit", "-n", ".", "-a", new_member, @resource[:name]]
                begin
                     execute(cmd)
                rescue Puppet::ExecutionFailure => detail
                     fail("Could not add %s to group: %s, %s" % [new_member, @resource.name, detail])
                end
            end
         end
     end
 
     def deletecmd
         # JJM: Like addcmd, only called when deleting the object itself
         #    Note, this isn't used to delete properties of the object,
         #    at least that's how I understand it...
         self.class.get_exec_preamble("-delete", @resource[:name])
     end
 
     def getinfo(refresh = false)
         # JJM 2007-07-24:
         #      Override the getinfo method, which is also defined in nameservice.rb
         #      This method returns and sets @infohash
         # I'm not re-factoring the name "getinfo" because this method will be
         # most likely called by nameservice.rb, which I didn't write.
         if refresh or (! defined?(@property_value_cache_hash) or ! @property_value_cache_hash)
             # JJM 2007-07-24: OK, there's a bit of magic that's about to
             # happen... Let's see how strong my grip has become... =)
             #
             # self is a provider instance of some Puppet::Type, like
             # Puppet::Type::User::ProviderDirectoryservice for the case of the
             # user type and this provider.
             #
             # self.class looks like "user provider directoryservice", if that
             # helps you ...
             #
             # self.class.resource_type is a reference to the Puppet::Type class,
             # probably Puppet::Type::User or Puppet::Type::Group, etc...
             #
             # self.class.resource_type.validproperties is a class method,
             # returning an Array of the valid properties of that specific
             # Puppet::Type.
             #
             # So... something like [:comment, :home, :password, :shell, :uid,
             # :groups, :ensure, :gid]
             #
             # Ultimately, we add :name to the list, delete :ensure from the
             # list, then report on the remaining list. Pretty whacky, ehh?
             type_properties = [:name] + self.class.resource_type.validproperties
             type_properties.delete(:ensure) if type_properties.include? :ensure
             type_properties << :guid  # append GeneratedUID so we just get the report here
             @property_value_cache_hash = self.class.single_report(@resource[:name], *type_properties)
             [:uid, :gid].each do |param|
                 @property_value_cache_hash[param] = @property_value_cache_hash[param].to_i if @property_value_cache_hash and @property_value_cache_hash.include?(param)
             end
         end
         return @property_value_cache_hash
     end
 end
 end
diff --git a/lib/puppet/util/metaid.rb b/lib/puppet/util/metaid.rb
index 0c38a5b1b..076775c76 100644
--- a/lib/puppet/util/metaid.rb
+++ b/lib/puppet/util/metaid.rb
@@ -1,21 +1,21 @@
 class Object
     # The hidden singleton lurks behind everyone
-    def metaclass; class << self; self; end; end
-    def meta_eval(&blk); metaclass.instance_eval(&blk); end
+    def singleton_class; class << self; self; end; end
+    def meta_eval(&blk); singleton_class.instance_eval(&blk); end
 
-    # Adds methods to a metaclass
+    # Adds methods to a singleton_class
     def meta_def(name, &blk)
         meta_eval { define_method name, &blk }
     end
 
-    # Remove metaclass methods.
+    # Remove singleton_class methods.
     def meta_undef(name, &blk)
         meta_eval { remove_method name }
     end
 
     # Defines an instance method within a class
     def class_def(name, &blk)
         class_eval { define_method name, &blk }
     end
 end
 
diff --git a/spec/unit/file_serving/content.rb b/spec/unit/file_serving/content.rb
index eacaff89f..111886d18 100755
--- a/spec/unit/file_serving/content.rb
+++ b/spec/unit/file_serving/content.rb
@@ -1,110 +1,110 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/file_serving/content'
 
 describe Puppet::FileServing::Content do
     it "should should be a subclass of Base" do
         Puppet::FileServing::Content.superclass.should equal(Puppet::FileServing::Base)
     end
 
     it "should indirect file_content" do
         Puppet::FileServing::Content.indirection.name.should == :file_content
     end
 
     it "should should include the IndirectionHooks module in its indirection" do
-        Puppet::FileServing::Content.indirection.metaclass.included_modules.should include(Puppet::FileServing::IndirectionHooks)
+        Puppet::FileServing::Content.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
     end
 
     it "should only support the raw format" do
         Puppet::FileServing::Content.supported_formats.should == [:raw]
     end
 
     it "should have a method for collecting its attributes" do
         Puppet::FileServing::Content.new("/path").should respond_to(:collect)
     end
 
     it "should retrieve and store its contents when its attributes are collected if the file is a normal file" do
         content = Puppet::FileServing::Content.new("/path")
 
         result = "foo"
         File.stubs(:lstat).returns(stub("stat", :ftype => "file"))
         File.expects(:read).with("/path").returns result
         content.collect
 
         content.instance_variable_get("@content").should_not be_nil
     end
 
     it "should not attempt to retrieve its contents if the file is a directory" do
         content = Puppet::FileServing::Content.new("/path")
 
         result = "foo"
         File.stubs(:lstat).returns(stub("stat", :ftype => "directory"))
         File.expects(:read).with("/path").never
         content.collect
 
         content.instance_variable_get("@content").should be_nil
     end
 
     it "should have a method for setting its content" do
         content = Puppet::FileServing::Content.new("/path")
         content.should respond_to(:content=)
     end
 
     it "should make content available when set externally" do
         content = Puppet::FileServing::Content.new("/path")
         content.content = "foo/bar"
         content.content.should == "foo/bar"
     end
 
     it "should be able to create a content instance from raw file contents" do
         Puppet::FileServing::Content.should respond_to(:from_raw)
     end
 
     it "should create an instance with a fake file name and correct content when converting from raw" do
         instance = mock 'instance'
         Puppet::FileServing::Content.expects(:new).with("/this/is/a/fake/path").returns instance
 
         instance.expects(:content=).with "foo/bar"
 
         Puppet::FileServing::Content.from_raw("foo/bar").should equal(instance)
     end
 end
 
 describe Puppet::FileServing::Content, "when returning the contents" do
     before do
         @path = "/my/path"
         @content = Puppet::FileServing::Content.new(@path, :links => :follow)
     end
 
     it "should fail if the file is a symlink and links are set to :manage" do
         @content.links = :manage
         File.expects(:lstat).with(@path).returns stub("stat", :ftype => "symlink")
         proc { @content.content }.should raise_error(ArgumentError)
     end
 
     it "should fail if a path is not set" do
         proc { @content.content() }.should raise_error(Errno::ENOENT)
     end
 
     it "should raise Errno::ENOENT if the file is absent" do
         @content.path = "/there/is/absolutely/no/chance/that/this/path/exists"
         proc { @content.content() }.should raise_error(Errno::ENOENT)
     end
 
     it "should return the contents of the path if the file exists" do
         File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
         File.expects(:read).with(@path).returns(:mycontent)
         @content.content.should == :mycontent
     end
 
     it "should cache the returned contents" do
         File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
         File.expects(:read).with(@path).returns(:mycontent)
         @content.content
 
         # The second run would throw a failure if the content weren't being cached.
         @content.content
     end
 end
diff --git a/spec/unit/file_serving/metadata.rb b/spec/unit/file_serving/metadata.rb
index 22f033d4d..ef2b3b6f0 100755
--- a/spec/unit/file_serving/metadata.rb
+++ b/spec/unit/file_serving/metadata.rb
@@ -1,286 +1,286 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/file_serving/metadata'
 
 describe Puppet::FileServing::Metadata do
     it "should should be a subclass of Base" do
         Puppet::FileServing::Metadata.superclass.should equal(Puppet::FileServing::Base)
     end
 
     it "should indirect file_metadata" do
         Puppet::FileServing::Metadata.indirection.name.should == :file_metadata
     end
 
     it "should should include the IndirectionHooks module in its indirection" do
-        Puppet::FileServing::Metadata.indirection.metaclass.included_modules.should include(Puppet::FileServing::IndirectionHooks)
+        Puppet::FileServing::Metadata.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
     end
 
     it "should have a method that triggers attribute collection" do
         Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:collect)
     end
 
     it "should support pson serialization" do
         Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson) 
     end
 
     it "should support to_pson_data_hash" do
         Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson_data_hash) 
     end
 
     it "should support pson deserialization" do
         Puppet::FileServing::Metadata.should respond_to(:from_pson) 
     end
 
     describe "when serializing" do
         before do
             @metadata = Puppet::FileServing::Metadata.new("/foo/bar")
         end
         it "should perform pson serialization by calling to_pson on it's pson_data_hash" do
             pdh = mock "data hash"
             pdh_as_pson = mock "data as pson"
             @metadata.expects(:to_pson_data_hash).returns pdh
             pdh.expects(:to_pson).returns pdh_as_pson
             @metadata.to_pson.should == pdh_as_pson 
         end
 
         it "should serialize as FileMetadata" do
             @metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
         end
 
         it "the data should include the path, relative_path, links, owner, group, mode, checksum, type, and destination" do
             @metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
         end
 
         it "should pass the path in the hash verbatum" do
             @metadata.to_pson_data_hash['data']['path'] == @metadata.path
         end
 
         it "should pass the relative_path in the hash verbatum" do
             @metadata.to_pson_data_hash['data']['relative_path'] == @metadata.relative_path
         end
 
         it "should pass the links in the hash verbatum" do
             @metadata.to_pson_data_hash['data']['links'] == @metadata.links
         end
 
         it "should pass the path owner in the hash verbatum" do
             @metadata.to_pson_data_hash['data']['owner'] == @metadata.owner
         end
 
         it "should pass the group in the hash verbatum" do
             @metadata.to_pson_data_hash['data']['group'] == @metadata.group
         end
 
         it "should pass the mode in the hash verbatum" do
             @metadata.to_pson_data_hash['data']['mode'] == @metadata.mode
         end
 
         it "should pass the ftype in the hash verbatum as the 'type'" do
             @metadata.to_pson_data_hash['data']['type'] == @metadata.ftype
         end
 
         it "should pass the destination verbatum" do
             @metadata.to_pson_data_hash['data']['destination'] == @metadata.destination
         end
 
         it "should pass the checksum in the hash as a nested hash" do
             @metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
         end
 
         it "should pass the checksum_type in the hash verbatum as the checksum's type" do
             @metadata.to_pson_data_hash['data']['checksum']['type'] == @metadata.checksum_type
         end
 
         it "should pass the checksum in the hash verbatum as the checksum's value" do
             @metadata.to_pson_data_hash['data']['checksum']['value'] == @metadata.checksum
         end
 
     end
 end
 
 describe Puppet::FileServing::Metadata, " when finding the file to use for setting attributes" do
     before do
         @path = "/my/path"
         @metadata = Puppet::FileServing::Metadata.new(@path)
 
         # Use a link because it's easier to test -- no checksumming
         @stat = stub "stat", :uid => 10, :gid => 20, :mode => 0755, :ftype => "link"
 
         # Not quite.  We don't want to checksum links, but we must because they might be being followed.
         @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
         @metadata.stubs(:md5_file).returns(@checksum)           #
     end
 
     it "should accept a base path path to which the file should be relative" do
         File.expects(:lstat).with(@path).returns @stat
         File.expects(:readlink).with(@path).returns "/what/ever"
         @metadata.collect
     end
 
     it "should use the set base path if one is not provided" do
         File.expects(:lstat).with(@path).returns @stat
         File.expects(:readlink).with(@path).returns "/what/ever"
         @metadata.collect()
     end
 
     it "should raise an exception if the file does not exist" do
         File.expects(:lstat).with(@path).raises(Errno::ENOENT)
         proc { @metadata.collect()}.should raise_error(Errno::ENOENT)
     end
 end
 
 describe Puppet::FileServing::Metadata, " when collecting attributes" do
     before do
         @path = "/my/file"
         # Use a real file mode, so we can validate the masking is done.
         @stat = stub 'stat', :uid => 10, :gid => 20, :mode => 33261, :ftype => "file"
         File.stubs(:lstat).returns(@stat)
         @checksum = Digest::MD5.hexdigest("some content\n")
         @metadata = Puppet::FileServing::Metadata.new("/my/file")
         @metadata.stubs(:md5_file).returns(@checksum)
         @metadata.collect
     end
 
     it "should be able to produce xmlrpc-style attribute information" do
         @metadata.should respond_to(:attributes_with_tabs)
     end
 
     # LAK:FIXME This should actually change at some point
     it "should set the owner by id" do
         @metadata.owner.should be_instance_of(Fixnum)
     end
 
     # LAK:FIXME This should actually change at some point
     it "should set the group by id" do
         @metadata.group.should be_instance_of(Fixnum)
     end
 
     it "should set the owner to the file's current owner" do
         @metadata.owner.should == 10
     end
 
     it "should set the group to the file's current group" do
         @metadata.group.should == 20
     end
 
     it "should set the mode to the file's masked mode" do
         @metadata.mode.should == 0755
     end
 
     it "should set the checksum to the file's current checksum" do
         @metadata.checksum.should == "{md5}" + @checksum
     end
 
     describe "when managing files" do
         it "should default to a checksum of type MD5" do
             @metadata.checksum.should == "{md5}" + @checksum
         end
 
         it "should give a mtime checksum when checksum_type is set" do
             time = Time.now
             @metadata.checksum_type = "mtime"
             @metadata.expects(:mtime_file).returns(@time)
             @metadata.collect
             @metadata.checksum.should == "{mtime}" + @time.to_s
         end
 
         it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
             @metadata.attributes_with_tabs.should == "#{0755.to_s}\tfile\t10\t20\t{md5}#{@checksum}"
         end
     end
 
     describe "when managing directories" do
         before do
             @stat.stubs(:ftype).returns("directory")
             @time = Time.now
             @metadata.expects(:ctime_file).returns(@time)
         end
 
         it "should only use checksums of type 'ctime' for directories" do
             @metadata.collect
             @metadata.checksum.should == "{ctime}" + @time.to_s
         end
 
         it "should only use checksums of type 'ctime' for directories even if checksum_type set" do
             @metadata.checksum_type = "mtime"
             @metadata.expects(:mtime_file).never
             @metadata.collect
             @metadata.checksum.should == "{ctime}" + @time.to_s
         end
 
         it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
             @metadata.collect
             @metadata.attributes_with_tabs.should == "#{0755.to_s}\tdirectory\t10\t20\t{ctime}#{@time.to_s}"
         end
     end
 
     describe "when managing links" do
         before do
             @stat.stubs(:ftype).returns("link")
             File.expects(:readlink).with("/my/file").returns("/path/to/link")
             @metadata.collect
  
             @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
             @file.stubs(:md5_file).returns(@checksum)           #
         end
 
         it "should read links instead of returning their checksums" do
             @metadata.destination.should == "/path/to/link"
         end
 
         it "should produce tab-separated mode, type, owner, group, and destination for xmlrpc" do
             pending "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
             @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t/path/to/link"
         end
 
         it "should produce tab-separated mode, type, owner, group, checksum, and destination for xmlrpc" do
             @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t{md5}eb9c2bf0eb63f3a7bc0ea37ef18aeba5\t/path/to/link"
         end
     end
 end
 
 describe Puppet::FileServing::Metadata, " when pointing to a link" do
     describe "when links are managed" do
         before do
             @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :manage)
             File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
             File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
 
             @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
             @file.stubs(:md5_file).returns(@checksum)           #
         end
         it "should store the destination of the link in :destination if links are :manage" do
             @file.collect
             @file.destination.should == "/some/other/path"
         end
         it "should not collect the checksum if links are :manage" do
             pending "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
             @file.collect
             @file.checksum.should be_nil
         end
         it "should collect the checksum if links are :manage" do # see pending note above
             @file.collect
             @file.checksum.should == "{md5}#{@checksum}"
         end
     end
 
     describe "when links are followed" do
         before do
             @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :follow)
             File.expects(:stat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
             File.expects(:readlink).with("/base/path/my/file").never
             @checksum = Digest::MD5.hexdigest("some content\n")
             @file.stubs(:md5_file).returns(@checksum)
         end
         it "should not store the destination of the link in :destination if links are :follow" do
             @file.collect
             @file.destination.should be_nil
         end
         it "should collect the checksum if links are :follow" do
             @file.collect
             @file.checksum.should == "{md5}#{@checksum}"
         end
     end
 end
diff --git a/spec/unit/indirector.rb b/spec/unit/indirector.rb
index 0b4c61695..64f7c4225 100755
--- a/spec/unit/indirector.rb
+++ b/spec/unit/indirector.rb
@@ -1,157 +1,157 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/defaults'
 require 'puppet/indirector'
 
 describe Puppet::Indirector, " when available to a model" do
     before do
         @thingie = Class.new do
             extend Puppet::Indirector
         end
     end
 
     it "should provide a way for the model to register an indirection under a name" do
         @thingie.should respond_to(:indirects)
     end
 end
 
 describe Puppet::Indirector, "when registering an indirection" do
     before do
         @thingie = Class.new do
             extend Puppet::Indirector
             attr_reader :name
             def initialize(name)
                 @name = name
             end
         end
     end
 
     it "should require a name when registering a model" do
         Proc.new {@thingie.send(:indirects) }.should raise_error(ArgumentError)
     end
 
     it "should create an indirection instance to manage each indirecting model" do
         @indirection = @thingie.indirects(:test)
         @indirection.should be_instance_of(Puppet::Indirector::Indirection)
     end
 
     it "should not allow a model to register under multiple names" do
         # Keep track of the indirection instance so we can delete it on cleanup
         @indirection = @thingie.indirects :first
         Proc.new { @thingie.indirects :second }.should raise_error(ArgumentError)
     end
 
     it "should make the indirection available via an accessor" do
         @indirection = @thingie.indirects :first
         @thingie.indirection.should equal(@indirection)
     end
 
     it "should pass any provided options to the indirection during initialization" do
         klass = mock 'terminus class'
         Puppet::Indirector::Indirection.expects(:new).with(@thingie, :first, {:some => :options})
         @indirection = @thingie.indirects :first, :some => :options
     end
 
     it "should extend the class with the Format Handler" do
         @indirection = @thingie.indirects :first
-        @thingie.metaclass.ancestors.should be_include(Puppet::Network::FormatHandler)
+        @thingie.singleton_class.ancestors.should be_include(Puppet::Network::FormatHandler)
     end
 
     after do
         @indirection.delete if @indirection
     end
 end
 
 describe "Delegated Indirection Method", :shared => true do
     it "should delegate to the indirection" do
         @indirection.expects(@method)
         @thingie.send(@method, "me")
     end
 
     it "should pass all of the passed arguments directly to the indirection instance" do
         @indirection.expects(@method).with("me", :one => :two)
         @thingie.send(@method, "me", :one => :two)
     end
 
     it "should return the results of the delegation as its result" do
         request = mock 'request'
         @indirection.expects(@method).returns "yay"
         @thingie.send(@method, "me").should == "yay"
     end
 end
 
 describe Puppet::Indirector, "when redirecting a model" do
     before do
         @thingie = Class.new do
             extend Puppet::Indirector
             attr_reader :name
             def initialize(name)
                 @name = name
             end
         end
         @indirection = @thingie.send(:indirects, :test)
     end
 
     it "should include the Envelope module in the model" do
         @thingie.ancestors.should be_include(Puppet::Indirector::Envelope)
     end
 
     describe "when finding instances via the model" do
         before { @method = :find }
         it_should_behave_like "Delegated Indirection Method"
     end
 
     describe "when destroying instances via the model" do
         before { @method = :destroy }
         it_should_behave_like "Delegated Indirection Method"
     end
 
     describe "when searching for instances via the model" do
         before { @method = :search }
         it_should_behave_like "Delegated Indirection Method"
     end
 
     describe "when expiring instances via the model" do
         before { @method = :expire }
         it_should_behave_like "Delegated Indirection Method"
     end
 
     # This is an instance method, so it behaves a bit differently.
     describe "when saving instances via the model" do
         before do
             @instance = @thingie.new("me")
         end
 
         it "should delegate to the indirection" do
             @indirection.expects(:save)
             @instance.save
         end
 
         it "should pass the instance and all arguments to the indirection's :save method" do
             @indirection.expects(:save).with(@instance, :one => :two)
             @instance.save :one => :two
         end
 
         it "should return the results of the delegation as its result" do
             request = mock 'request'
             @indirection.expects(:save).returns "yay"
             @instance.save.should == "yay"
         end
     end
 
     it "should give the model the ability to set the indirection terminus class" do
         @indirection.expects(:terminus_class=).with(:myterm)
         @thingie.terminus_class = :myterm
     end
 
     it "should give the model the ability to set the indirection cache class" do
         @indirection.expects(:cache_class=).with(:mycache)
         @thingie.cache_class = :mycache
     end
 
     after do
         @indirection.delete
     end
 end
diff --git a/spec/unit/indirector/indirection.rb b/spec/unit/indirector/indirection.rb
index 311cc5323..2ed51d7c4 100755
--- a/spec/unit/indirector/indirection.rb
+++ b/spec/unit/indirector/indirection.rb
@@ -1,795 +1,795 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/indirector/indirection'
 
 describe "Indirection Delegator", :shared => true do
     it "should create a request object with the appropriate method name and all of the passed arguments" do
         request = Puppet::Indirector::Request.new(:indirection, :find, "me")
 
         @indirection.expects(:request).with(@method, "mystuff", :one => :two).returns request
 
         @terminus.stubs(@method)
 
         @indirection.send(@method, "mystuff", :one => :two)
     end
 
     it "should let the :select_terminus method choose the terminus using the created request if the :select_terminus method is available" do
         # Define the method, so our respond_to? hook matches.
         class << @indirection
             def select_terminus(request)
             end
         end
 
         request = Puppet::Indirector::Request.new(:indirection, :find, "me")
 
         @indirection.stubs(:request).returns request
 
         @indirection.expects(:select_terminus).with(request).returns :test_terminus
 
         @indirection.stubs(:check_authorization)
         @terminus.expects(@method)
 
         @indirection.send(@method, "me")
     end
 
     it "should fail if the :select_terminus hook does not return a terminus name" do
         # Define the method, so our respond_to? hook matches.
         class << @indirection
             def select_terminus(request)
             end
         end
 
         request = stub 'request', :key => "me", :options => {}
 
         @indirection.stubs(:request).returns request
 
         @indirection.expects(:select_terminus).with(request).returns nil
 
         lambda { @indirection.send(@method, "me") }.should raise_error(ArgumentError)
     end
 
     it "should choose the terminus returned by the :terminus_class method if no :select_terminus method is available" do
         @indirection.expects(:terminus_class).returns :test_terminus
 
         @terminus.expects(@method)
 
         @indirection.send(@method, "me")
     end
 
     it "should let the appropriate terminus perform the lookup" do
         @terminus.expects(@method).with { |r| r.is_a?(Puppet::Indirector::Request) }
         @indirection.send(@method, "me")
     end
 end
 
 describe "Delegation Authorizer", :shared => true do
     before do
         # So the :respond_to? turns out correctly.
         class << @terminus
             def authorized?
             end
         end
     end
 
     it "should not check authorization if a node name is not provided" do
         @terminus.expects(:authorized?).never
         @terminus.stubs(@method)
 
         # The quotes are necessary here, else it looks like a block.
         @request.stubs(:options).returns({})
         @indirection.send(@method, "/my/key")
     end
 
     it "should pass the request to the terminus's authorization method" do
         @terminus.expects(:authorized?).with { |r| r.is_a?(Puppet::Indirector::Request) }.returns(true)
         @terminus.stubs(@method)
 
         @indirection.send(@method, "/my/key", :node => "mynode")
     end
 
     it "should fail if authorization returns false" do
         @terminus.expects(:authorized?).returns(false)
         @terminus.stubs(@method)
         proc { @indirection.send(@method, "/my/key", :node => "mynode") }.should raise_error(ArgumentError)
     end
 
     it "should continue if authorization returns true" do
         @terminus.expects(:authorized?).returns(true)
         @terminus.stubs(@method)
         @indirection.send(@method, "/my/key", :node => "mynode")
     end
 end
 
 describe Puppet::Indirector::Indirection do
     after do
         Puppet::Util::Cacher.expire
     end
     describe "when initializing" do
         # (LAK) I've no idea how to test this, really.
         it "should store a reference to itself before it consumes its options" do
             proc { @indirection = Puppet::Indirector::Indirection.new(Object.new, :testingness, :not_valid_option) }.should raise_error
             Puppet::Indirector::Indirection.instance(:testingness).should be_instance_of(Puppet::Indirector::Indirection)
             Puppet::Indirector::Indirection.instance(:testingness).delete
         end
 
         it "should keep a reference to the indirecting model" do
             model = mock 'model'
             @indirection = Puppet::Indirector::Indirection.new(model, :myind)
             @indirection.model.should equal(model)
         end
 
         it "should set the name" do
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :myind)
             @indirection.name.should == :myind
         end
 
         it "should require indirections to have unique names" do
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
             proc { Puppet::Indirector::Indirection.new(:test) }.should raise_error(ArgumentError)
         end
 
         it "should extend itself with any specified module" do
             mod = Module.new
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test, :extend => mod)
-            @indirection.metaclass.included_modules.should include(mod)
+            @indirection.singleton_class.included_modules.should include(mod)
         end
 
         after do
             @indirection.delete if defined? @indirection
         end
     end
 
     describe "when an instance" do
         before :each do
             @terminus_class = mock 'terminus_class'
             @terminus = mock 'terminus'
             @terminus_class.stubs(:new).returns(@terminus)
             @cache = stub 'cache', :name => "mycache"
             @cache_class = mock 'cache_class'
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :cache_terminus).returns(@cache_class)
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :test_terminus).returns(@terminus_class)
 
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
             @indirection.terminus_class = :test_terminus
 
             @instance = stub 'instance', :expiration => nil, :expiration= => nil, :name => "whatever"
             @name = :mything
 
             #@request = stub 'instance', :key => "/my/key", :instance => @instance, :options => {}
             @request = mock 'instance'
         end
 
         it "should allow setting the ttl" do
             @indirection.ttl = 300
             @indirection.ttl.should == 300
         end
 
         it "should default to the :runinterval setting, converted to an integer, for its ttl" do
             Puppet.settings.expects(:value).returns "1800"
             @indirection.ttl.should == 1800
         end
 
         it "should calculate the current expiration by adding the TTL to the current time" do
             @indirection.stubs(:ttl).returns(100)
             now = Time.now
             Time.stubs(:now).returns now
             @indirection.expiration.should == (Time.now + 100)
         end
 
         it "should have a method for creating an indirection request instance" do
             @indirection.should respond_to(:request)
         end
 
         describe "creates a request" do
             it "should create it with its name as the request's indirection name" do
                 Puppet::Indirector::Request.expects(:new).with { |name, *other| @indirection.name == name }
                 @indirection.request(:funtest, "yayness")
             end
 
             it "should require a method and key" do
                 Puppet::Indirector::Request.expects(:new).with { |name, method, key, *other| method == :funtest and key == "yayness" }
                 @indirection.request(:funtest, "yayness")
             end
 
             it "should support optional arguments" do
                 Puppet::Indirector::Request.expects(:new).with { |name, method, key, other| other == {:one => :two} }
                 @indirection.request(:funtest, "yayness", :one => :two)
             end
 
             it "should default to the arguments being nil" do
                 Puppet::Indirector::Request.expects(:new).with { |name, method, key, args| args.nil? }
                 @indirection.request(:funtest, "yayness")
             end
 
             it "should return the request" do
                 request = mock 'request'
                 Puppet::Indirector::Request.expects(:new).returns request
                 @indirection.request(:funtest, "yayness").should equal(request)
             end
         end
 
         describe "and looking for a model instance" do
             before { @method = :find }
 
             it_should_behave_like "Indirection Delegator"
             it_should_behave_like "Delegation Authorizer"
 
             it "should return the results of the delegation" do
                 @terminus.expects(:find).returns(@instance)
                 @indirection.find("me").should equal(@instance)
             end
 
             it "should set the expiration date on any instances without one set" do
                 @terminus.stubs(:find).returns(@instance)
 
                 @indirection.expects(:expiration).returns :yay
 
                 @instance.expects(:expiration).returns(nil)
                 @instance.expects(:expiration=).with(:yay)
 
                 @indirection.find("/my/key")
             end
 
             it "should not override an already-set expiration date on returned instances" do
                 @terminus.stubs(:find).returns(@instance)
 
                 @indirection.expects(:expiration).never
 
                 @instance.expects(:expiration).returns(:yay)
                 @instance.expects(:expiration=).never
 
                 @indirection.find("/my/key")
             end
 
             it "should filter the result instance if the terminus supports it" do
                 @terminus.stubs(:find).returns(@instance)
                 @terminus.stubs(:respond_to?).with(:filter).returns(true)
 
                 @terminus.expects(:filter).with(@instance)
 
                 @indirection.find("/my/key")
             end
             describe "when caching is enabled" do
                 before do
                     @indirection.cache_class = :cache_terminus
                     @cache_class.stubs(:new).returns(@cache)
 
                     @instance.stubs(:expired?).returns false
                 end
 
                 it "should first look in the cache for an instance" do
                     @terminus.stubs(:find).never
                     @cache.expects(:find).returns @instance
 
                     @indirection.find("/my/key")
                 end
 
                 it "should not look in the cache if the request specifies not to use the cache" do
                     @terminus.expects(:find).returns @instance
                     @cache.expects(:find).never
                     @cache.stubs(:save)
 
                     @indirection.find("/my/key", :ignore_cache => true)
                 end
 
                 it "should still save to the cache even if the cache is being ignored during readin" do
                     @terminus.expects(:find).returns @instance
                     @cache.expects(:save)
 
                     @indirection.find("/my/key", :ignore_cache => true)
                 end
 
                 it "should only look in the cache if the request specifies not to use the terminus" do
                     @terminus.expects(:find).never
                     @cache.expects(:find)
 
                     @indirection.find("/my/key", :ignore_terminus => true)
                 end
 
                 it "should use a request to look in the cache for cached objects" do
                     @cache.expects(:find).with { |r| r.method == :find and r.key == "/my/key" }.returns @instance
 
                     @cache.stubs(:save)
 
                     @indirection.find("/my/key")
                 end
 
                 it "should return the cached object if it is not expired" do
                     @instance.stubs(:expired?).returns false
 
                     @cache.stubs(:find).returns @instance
                     @indirection.find("/my/key").should equal(@instance)
                 end
 
                 it "should not fail if the cache fails" do
                     @terminus.stubs(:find).returns @instance
 
                     @cache.expects(:find).raises ArgumentError
                     @cache.stubs(:save)
                     lambda { @indirection.find("/my/key") }.should_not raise_error
                 end
 
                 it "should look in the main terminus if the cache fails" do
                     @terminus.expects(:find).returns @instance
                     @cache.expects(:find).raises ArgumentError
                     @cache.stubs(:save)
                     @indirection.find("/my/key").should equal(@instance)
                 end
 
                 it "should send a debug log if it is using the cached object" do
                     Puppet.expects(:debug)
                     @cache.stubs(:find).returns @instance
 
                     @indirection.find("/my/key")
                 end
 
                 it "should not return the cached object if it is expired" do
                     @instance.stubs(:expired?).returns true
 
                     @cache.stubs(:find).returns @instance
                     @terminus.stubs(:find).returns nil
                     @indirection.find("/my/key").should be_nil
                 end
 
                 it "should send an info log if it is using the cached object" do
                     Puppet.expects(:info)
                     @instance.stubs(:expired?).returns true
 
                     @cache.stubs(:find).returns @instance
                     @terminus.stubs(:find).returns nil
                     @indirection.find("/my/key")
                 end
 
                 it "should cache any objects not retrieved from the cache" do
                     @cache.expects(:find).returns nil
 
                     @terminus.expects(:find).returns(@instance)
                     @cache.expects(:save)
 
                     @indirection.find("/my/key")
                 end
 
                 it "should use a request to look in the cache for cached objects" do
                     @cache.expects(:find).with { |r| r.method == :find and r.key == "/my/key" }.returns nil
 
                     @terminus.stubs(:find).returns(@instance)
                     @cache.stubs(:save)
 
                     @indirection.find("/my/key")
                 end
 
                 it "should cache the instance using a request with the instance set to the cached object" do
                     @cache.stubs(:find).returns nil
 
                     @terminus.stubs(:find).returns(@instance)
 
                     @cache.expects(:save).with { |r| r.method == :save and r.instance == @instance }
 
                     @indirection.find("/my/key")
                 end
 
                 it "should send an info log that the object is being cached" do
                     @cache.stubs(:find).returns nil
 
                     @terminus.stubs(:find).returns(@instance)
                     @cache.stubs(:save)
 
                     Puppet.expects(:info)
 
                     @indirection.find("/my/key")
                 end
             end
         end
 
         describe "and storing a model instance" do
             before { @method = :save }
 
             it_should_behave_like "Indirection Delegator"
             it_should_behave_like "Delegation Authorizer"
 
             it "should return the result of the save" do
                 @terminus.stubs(:save).returns "foo"
                 @indirection.save(@instance).should == "foo"
             end
 
             describe "when caching is enabled" do
                 before do
                     @indirection.cache_class = :cache_terminus
                     @cache_class.stubs(:new).returns(@cache)
 
                     @instance.stubs(:expired?).returns false
                 end
 
                 it "should return the result of saving to the terminus" do
                     request = stub 'request', :instance => @instance, :node => nil
 
                     @indirection.expects(:request).returns request
 
                     @cache.stubs(:save)
                     @terminus.stubs(:save).returns @instance
                     @indirection.save(@instance).should equal(@instance)
                 end
 
                 it "should use a request to save the object to the cache" do
                     request = stub 'request', :instance => @instance, :node => nil
 
                     @indirection.expects(:request).returns request
 
                     @cache.expects(:save).with(request)
                     @terminus.stubs(:save)
                     @indirection.save(@instance)
                 end
 
                 it "should not save to the cache if the normal save fails" do
                     request = stub 'request', :instance => @instance, :node => nil
 
                     @indirection.expects(:request).returns request
 
                     @cache.expects(:save).never
                     @terminus.expects(:save).raises "eh"
                     lambda { @indirection.save(@instance) }.should raise_error
                 end
             end
         end
 
         describe "and removing a model instance" do
             before { @method = :destroy }
 
             it_should_behave_like "Indirection Delegator"
             it_should_behave_like "Delegation Authorizer"
 
             it "should return the result of removing the instance" do
                 @terminus.stubs(:destroy).returns "yayness"
                 @indirection.destroy("/my/key").should == "yayness"
             end
 
             describe "when caching is enabled" do
                 before do
                     @indirection.cache_class = :cache_terminus
                     @cache_class.expects(:new).returns(@cache)
 
                     @instance.stubs(:expired?).returns false
                 end
 
                 it "should use a request instance to search in and remove objects from the cache" do
                     destroy = stub 'destroy_request', :key => "/my/key", :node => nil
                     find = stub 'destroy_request', :key => "/my/key", :node => nil
 
                     @indirection.expects(:request).with(:destroy, "/my/key").returns destroy
                     @indirection.expects(:request).with(:find, "/my/key").returns find
 
                     cached = mock 'cache'
 
                     @cache.expects(:find).with(find).returns cached
                     @cache.expects(:destroy).with(destroy)
 
                     @terminus.stubs(:destroy)
 
                     @indirection.destroy("/my/key")
                 end
             end
         end
 
         describe "and searching for multiple model instances" do
             before { @method = :search }
 
             it_should_behave_like "Indirection Delegator"
             it_should_behave_like "Delegation Authorizer"
 
             it "should set the expiration date on any instances without one set" do
                 @terminus.stubs(:search).returns([@instance])
 
                 @indirection.expects(:expiration).returns :yay
 
                 @instance.expects(:expiration).returns(nil)
                 @instance.expects(:expiration=).with(:yay)
 
                 @indirection.search("/my/key")
             end
 
             it "should not override an already-set expiration date on returned instances" do
                 @terminus.stubs(:search).returns([@instance])
 
                 @indirection.expects(:expiration).never
 
                 @instance.expects(:expiration).returns(:yay)
                 @instance.expects(:expiration=).never
 
                 @indirection.search("/my/key")
             end
 
             it "should return the results of searching in the terminus" do
                 @terminus.expects(:search).returns([@instance])
                 @indirection.search("/my/key").should == [@instance]
             end
         end
 
         describe "and expiring a model instance" do
             describe "when caching is not enabled" do
                 it "should do nothing" do
                     @cache_class.expects(:new).never
 
                     @indirection.expire("/my/key")
                 end
             end
 
             describe "when caching is enabled" do
                 before do
                     @indirection.cache_class = :cache_terminus
                     @cache_class.expects(:new).returns(@cache)
 
                     @instance.stubs(:expired?).returns false
 
                     @cached = stub 'cached', :expiration= => nil, :name => "/my/key"
                 end
 
                 it "should use a request to find within the cache" do
                     @cache.expects(:find).with { |r| r.is_a?(Puppet::Indirector::Request) and r.method == :find }
                     @indirection.expire("/my/key")
                 end
 
                 it "should do nothing if no such instance is cached" do
                     @cache.expects(:find).returns nil
 
                     @indirection.expire("/my/key")
                 end
 
                 it "should log when expiring a found instance" do
                     @cache.expects(:find).returns @cached
                     @cache.stubs(:save)
 
                     Puppet.expects(:info)
 
                     @indirection.expire("/my/key")
                 end
 
                 it "should set the cached instance's expiration to a time in the past" do
                     @cache.expects(:find).returns @cached
                     @cache.stubs(:save)
 
                     @cached.expects(:expiration=).with { |t| t < Time.now }
 
                     @indirection.expire("/my/key")
                 end
 
                 it "should save the now expired instance back into the cache" do
                     @cache.expects(:find).returns @cached
 
                     @cached.expects(:expiration=).with { |t| t < Time.now }
 
                     @cache.expects(:save)
 
                     @indirection.expire("/my/key")
                 end
 
                 it "should use a request to save the expired resource to the cache" do
                     @cache.expects(:find).returns @cached
 
                     @cached.expects(:expiration=).with { |t| t < Time.now }
 
                     @cache.expects(:save).with { |r| r.is_a?(Puppet::Indirector::Request) and r.instance == @cached and r.method == :save }.returns(@cached)
 
                     @indirection.expire("/my/key")
                 end
             end
         end
 
         after :each do
             @indirection.delete
             Puppet::Util::Cacher.expire
         end
     end
 
 
     describe "when managing indirection instances" do
         it "should allow an indirection to be retrieved by name" do
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
             Puppet::Indirector::Indirection.instance(:test).should equal(@indirection)
         end
 
         it "should return nil when the named indirection has not been created" do
             Puppet::Indirector::Indirection.instance(:test).should be_nil
         end
 
         it "should allow an indirection's model to be retrieved by name" do
             mock_model = mock('model')
             @indirection = Puppet::Indirector::Indirection.new(mock_model, :test)
             Puppet::Indirector::Indirection.model(:test).should equal(mock_model)
         end
 
         it "should return nil when no model matches the requested name" do
             Puppet::Indirector::Indirection.model(:test).should be_nil
         end
 
         after do
             @indirection.delete if defined? @indirection
         end
     end
 
     describe "when routing to the correct the terminus class" do
         before do
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
             @terminus = mock 'terminus'
             @terminus_class = stub 'terminus class', :new => @terminus
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :default).returns(@terminus_class)
         end
 
         it "should fail if no terminus class can be picked" do
             proc { @indirection.terminus_class }.should raise_error(Puppet::DevError)
         end
 
         it "should choose the default terminus class if one is specified" do
             @indirection.terminus_class = :default
             @indirection.terminus_class.should equal(:default)
         end
 
         it "should use the provided Puppet setting if told to do so" do
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :my_terminus).returns(mock("terminus_class2"))
             Puppet.settings.expects(:value).with(:my_setting).returns("my_terminus")
             @indirection.terminus_setting = :my_setting
             @indirection.terminus_class.should equal(:my_terminus)
         end
 
         it "should fail if the provided terminus class is not valid" do
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :nosuchclass).returns(nil)
             proc { @indirection.terminus_class = :nosuchclass }.should raise_error(ArgumentError)
         end
 
         after do
             @indirection.delete if defined? @indirection
         end
     end
 
     describe "when specifying the terminus class to use" do
         before do
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
             @terminus = mock 'terminus'
             @terminus_class = stub 'terminus class', :new => @terminus
         end
 
         it "should allow specification of a terminus type" do
             @indirection.should respond_to(:terminus_class=)
         end
 
         it "should fail to redirect if no terminus type has been specified" do
             proc { @indirection.find("blah") }.should raise_error(Puppet::DevError)
         end
 
         it "should fail when the terminus class name is an empty string" do
             proc { @indirection.terminus_class = "" }.should raise_error(ArgumentError)
         end
 
         it "should fail when the terminus class name is nil" do
             proc { @indirection.terminus_class = nil }.should raise_error(ArgumentError)
         end
 
         it "should fail when the specified terminus class cannot be found" do
             Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(nil)
             proc { @indirection.terminus_class = :foo }.should raise_error(ArgumentError)
         end
 
         it "should select the specified terminus class if a terminus class name is provided" do
             Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(@terminus_class)
             @indirection.terminus(:foo).should equal(@terminus)
         end
 
         it "should use the configured terminus class if no terminus name is specified" do
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
             @indirection.terminus_class = :foo
             @indirection.terminus().should equal(@terminus)
         end
 
         after do
             @indirection.delete if defined? @indirection
         end
     end
 
     describe "when managing terminus instances" do
         before do
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
             @terminus = mock 'terminus'
             @terminus_class = mock 'terminus class'
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
         end
 
         it "should create an instance of the chosen terminus class" do
             @terminus_class.stubs(:new).returns(@terminus)
             @indirection.terminus(:foo).should equal(@terminus)
         end
 
         # Make sure it caches the terminus.
         it "should return the same terminus instance each time for a given name" do
             @terminus_class.stubs(:new).returns(@terminus)
             @indirection.terminus(:foo).should equal(@terminus)
             @indirection.terminus(:foo).should equal(@terminus)
         end
 
         it "should not create a terminus instance until one is actually needed" do
             Puppet::Indirector.expects(:terminus).never
             indirection = Puppet::Indirector::Indirection.new(mock('model'), :lazytest)
         end
 
         after do
             @indirection.delete
         end
     end
 
     describe "when deciding whether to cache" do
         before do
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
             @terminus = mock 'terminus'
             @terminus_class = mock 'terminus class'
             @terminus_class.stubs(:new).returns(@terminus)
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
             @indirection.terminus_class = :foo
         end
 
         it "should provide a method for setting the cache terminus class" do
             @indirection.should respond_to(:cache_class=)
         end
 
         it "should fail to cache if no cache type has been specified" do
             proc { @indirection.cache }.should raise_error(Puppet::DevError)
         end
 
         it "should fail to set the cache class when the cache class name is an empty string" do
             proc { @indirection.cache_class = "" }.should raise_error(ArgumentError)
         end
 
         it "should allow resetting the cache_class to nil" do
             @indirection.cache_class = nil
             @indirection.cache_class.should be_nil
         end
 
         it "should fail to set the cache class when the specified cache class cannot be found" do
             Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(nil)
             proc { @indirection.cache_class = :foo }.should raise_error(ArgumentError)
         end
 
         after do
             @indirection.delete
         end
     end
 
     describe "when using a cache" do
         before :each do
             Puppet.settings.stubs(:value).with("test_terminus").returns("test_terminus")
             @terminus_class = mock 'terminus_class'
             @terminus = mock 'terminus'
             @terminus_class.stubs(:new).returns(@terminus)
             @cache = mock 'cache'
             @cache_class = mock 'cache_class'
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :cache_terminus).returns(@cache_class)
             Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :test_terminus).returns(@terminus_class)
             @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
             @indirection.terminus_class = :test_terminus
         end
 
         describe "and managing the cache terminus" do
             it "should not create a cache terminus at initialization" do
                 # This is weird, because all of the code is in the setup.  If we got
                 # new() called on the cache class, we'd get an exception here.
             end
 
             it "should reuse the cache terminus" do
                 @cache_class.expects(:new).returns(@cache)
                 Puppet.settings.stubs(:value).with("test_cache").returns("cache_terminus")
                 @indirection.cache_class = :cache_terminus
                 @indirection.cache.should equal(@cache)
                 @indirection.cache.should equal(@cache)
             end
         end
 
         describe "and saving" do
         end
 
         describe "and finding" do
         end
 
         after :each do
             @indirection.delete
         end
     end
 end
diff --git a/spec/unit/indirector/yaml.rb b/spec/unit/indirector/yaml.rb
index 7536fbc25..0e7070814 100755
--- a/spec/unit/indirector/yaml.rb
+++ b/spec/unit/indirector/yaml.rb
@@ -1,145 +1,145 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/indirector/yaml'
 
 describe Puppet::Indirector::Yaml, " when choosing file location" do
     before :each do
         @indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
         Puppet::Indirector::Indirection.stubs(:instance).with(:my_yaml).returns(@indirection)
         @store_class = Class.new(Puppet::Indirector::Yaml) do
             def self.to_s
                 "MyYaml::MyType"
             end
         end
         @store = @store_class.new
 
         @subject = Object.new
-        @subject.metaclass.send(:attr_accessor, :name)
+        @subject.singleton_class.send(:attr_accessor, :name)
         @subject.name = :me
 
         @dir = "/what/ever"
         Puppet.settings.stubs(:value).returns("fakesettingdata")
         Puppet.settings.stubs(:value).with(:clientyamldir).returns(@dir)
 
         @request = stub 'request', :key => :me, :instance => @subject
     end
 
     describe Puppet::Indirector::Yaml, " when choosing file location" do
         it "should use the yamldir if the process name is 'puppetmasterd'" do
             Puppet.settings.expects(:value).with(:name).returns "puppetmasterd"
             Puppet.settings.expects(:value).with(:yamldir).returns "/main/yaml/dir"
             @store.path(:me).should =~ %r{^/main/yaml/dir}
         end
 
         it "should use the client yamldir if the process name is not 'puppetmasterd'" do
             Puppet.settings.expects(:value).with(:name).returns "cient"
             Puppet.settings.expects(:value).with(:clientyamldir).returns "/client/yaml/dir"
             @store.path(:me).should =~ %r{^/client/yaml/dir}
         end
 
         it "should store all files in a single file root set in the Puppet defaults" do
             @store.path(:me).should =~ %r{^#{@dir}}
         end
 
         it "should use the terminus name for choosing the subdirectory" do
             @store.path(:me).should =~ %r{^#{@dir}/my_yaml}
         end
 
         it "should use the object's name to determine the file name" do
             @store.path(:me).should =~ %r{me.yaml$}
         end
     end
 
     describe Puppet::Indirector::Yaml, " when storing objects as YAML" do
         it "should only store objects that respond to :name" do
             @request.stubs(:instance).returns Object.new
             proc { @store.save(@request) }.should raise_error(ArgumentError)
         end
 
         it "should convert Ruby objects to YAML and write them to disk using a write lock" do
             yaml = @subject.to_yaml
             file = mock 'file'
             path = @store.send(:path, @subject.name)
             FileTest.expects(:exist?).with(File.dirname(path)).returns(true)
             @store.expects(:writelock).with(path, 0660).yields(file)
             file.expects(:print).with(yaml)
 
             @store.save(@request)
         end
 
         it "should create the indirection subdirectory if it does not exist" do
             yaml = @subject.to_yaml
             file = mock 'file'
             path = @store.send(:path, @subject.name)
             dir = File.dirname(path)
 
             FileTest.expects(:exist?).with(dir).returns(false)
             Dir.expects(:mkdir).with(dir)
 
             @store.expects(:writelock).yields(file)
             file.expects(:print).with(yaml)
 
             @store.save(@request)
         end
     end
 
     describe Puppet::Indirector::Yaml, " when retrieving YAML" do
         it "should read YAML in from disk using a read lock and convert it to Ruby objects" do
             path = @store.send(:path, @subject.name)
 
             yaml = @subject.to_yaml
             FileTest.expects(:exist?).with(path).returns(true)
 
             fh = mock 'filehandle'
             @store.expects(:readlock).with(path).yields fh
             fh.expects(:read).returns yaml
 
             @store.find(@request).instance_variable_get("@name").should == :me
         end
 
         it "should fail coherently when the stored YAML is invalid" do
             path = @store.send(:path, @subject.name)
             FileTest.expects(:exist?).with(path).returns(true)
 
             # Something that will fail in yaml
             yaml = "--- !ruby/object:Hash"
 
             fh = mock 'filehandle'
             @store.expects(:readlock).yields fh
             fh.expects(:read).returns yaml
 
             proc { @store.find(@request) }.should raise_error(Puppet::Error)
         end
     end
 
     describe Puppet::Indirector::Yaml, " when searching" do
       it "should return an array of fact instances with one instance for each file when globbing *" do
         @request = stub 'request', :key => "*", :instance => @subject
         @one = mock 'one'
         @two = mock 'two'
         @store.expects(:base).returns "/my/yaml/dir"
         Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns(%w{one.yaml two.yaml})
         YAML.expects(:load_file).with("one.yaml").returns @one;
         YAML.expects(:load_file).with("two.yaml").returns @two;
         @store.search(@request).should == [@one, @two]
       end
 
       it "should return an array containing a single instance of fact when globbing 'one*'" do
         @request = stub 'request', :key => "one*", :instance => @subject
         @one = mock 'one'
         @store.expects(:base).returns "/my/yaml/dir"
         Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns(%w{one.yaml})
         YAML.expects(:load_file).with("one.yaml").returns @one;
         @store.search(@request).should == [@one]
       end
 
       it "should return an empty array when the glob doesn't match anything" do
         @request = stub 'request', :key => "f*ilglobcanfail*", :instance => @subject
         @store.expects(:base).returns "/my/yaml/dir"
         Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns([])
         @store.search(@request).should == []
       end
     end
 end
diff --git a/spec/unit/relationship.rb b/spec/unit/relationship.rb
index 5a52cb587..b98e4e26e 100755
--- a/spec/unit/relationship.rb
+++ b/spec/unit/relationship.rb
@@ -1,236 +1,236 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-11-1.
 #  Copyright (c) 2006. All rights reserved.
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/relationship'
 
 describe Puppet::Relationship do
     before do
         @edge = Puppet::Relationship.new(:a, :b)
     end
 
     it "should have a :source attribute" do
         @edge.should respond_to(:source)
     end
 
     it "should have a :target attribute" do
         @edge.should respond_to(:target)
     end
 
     it "should have a :callback attribute" do
         @edge.callback = :foo
         @edge.callback.should == :foo
     end
 
     it "should have an :event attribute" do
         @edge.event = :NONE
         @edge.event.should == :NONE
     end
 
     it "should require a callback if a non-NONE event is specified" do
         proc { @edge.event = :something }.should raise_error(ArgumentError)
     end
 
     it "should have a :label attribute" do
         @edge.should respond_to(:label)
     end
 
     it "should provide a :ref method that describes the edge" do
         @edge = Puppet::Relationship.new("a", "b")
         @edge.ref.should == "a => b"
     end
 
     it "should be able to produce a label as a hash with its event and callback" do
         @edge.callback = :foo
         @edge.event = :bar
 
         @edge.label.should == {:callback => :foo, :event => :bar}
     end
 
     it "should work if nil options are provided" do
         lambda { Puppet::Relationship.new("a", "b", nil) }.should_not raise_error
     end
 end
 
 describe Puppet::Relationship, " when initializing" do
     before do
         @edge = Puppet::Relationship.new(:a, :b)
     end
 
     it "should use the first argument as the source" do
         @edge.source.should == :a
     end
 
     it "should use the second argument as the target" do
         @edge.target.should == :b
     end
 
     it "should set the rest of the arguments as the event and callback" do
         @edge = Puppet::Relationship.new(:a, :b, :callback => :foo, :event => :bar)
         @edge.callback.should == :foo
         @edge.event.should == :bar
     end
 
     it "should accept events specified as strings" do
         @edge = Puppet::Relationship.new(:a, :b, "event" => :NONE)
         @edge.event.should == :NONE
     end
 
     it "should accept callbacks specified as strings" do
         @edge = Puppet::Relationship.new(:a, :b, "callback" => :foo)
         @edge.callback.should == :foo
     end
 end
 
 describe Puppet::Relationship, " when matching edges with no specified event" do
     before do
         @edge = Puppet::Relationship.new(:a, :b)
     end
 
     it "should not match :NONE" do
         @edge.should_not be_match(:NONE)
     end
 
     it "should not match :ALL_EVENTS" do
         @edge.should_not be_match(:NONE)
     end
 
     it "should not match any other events" do
         @edge.should_not be_match(:whatever)
     end
 end
 
 describe Puppet::Relationship, " when matching edges with :NONE as the event" do
     before do
         @edge = Puppet::Relationship.new(:a, :b, :event => :NONE)
     end
     it "should not match :NONE" do
         @edge.should_not be_match(:NONE)
     end
 
     it "should not match :ALL_EVENTS" do
         @edge.should_not be_match(:ALL_EVENTS)
     end
 
     it "should not match other events" do
         @edge.should_not be_match(:yayness)
     end
 end
 
 describe Puppet::Relationship, " when matching edges with :ALL as the event" do
     before do
         @edge = Puppet::Relationship.new(:a, :b, :event => :ALL_EVENTS, :callback => :whatever)
     end
 
     it "should not match :NONE" do
         @edge.should_not be_match(:NONE)
     end
 
     it "should match :ALL_EVENTS" do
         @edge.should be_match(:ALLEVENTS)
     end
 
     it "should match all other events" do
         @edge.should be_match(:foo)
     end
 end
 
 describe Puppet::Relationship, " when matching edges with a non-standard event" do
     before do
         @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
     end
 
     it "should not match :NONE" do
         @edge.should_not be_match(:NONE)
     end
 
     it "should not match :ALL_EVENTS" do
         @edge.should_not be_match(:ALL_EVENTS)
     end
 
     it "should match events with the same name" do
         @edge.should be_match(:random)
     end
 end
 
 describe Puppet::Relationship, "when converting to pson" do
     confine "Missing 'pson' library" => Puppet.features.pson?
 
     before do
         @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
     end
 
     it "should store the stringified source as the source in the data" do
         PSON.parse(@edge.to_pson)["source"].should == "a"
     end
 
     it "should store the stringified target as the target in the data" do
         PSON.parse(@edge.to_pson)['target'].should == "b"
     end
 
     it "should store the psonified event as the event in the data" do
         PSON.parse(@edge.to_pson)["event"].should == "random"
     end
 
     it "should not store an event when none is set" do
         @edge.event = nil
         PSON.parse(@edge.to_pson)["event"].should be_nil
     end
 
     it "should store the psonified callback as the callback in the data" do
         @edge.callback = "whatever"
         PSON.parse(@edge.to_pson)["callback"].should == "whatever"
     end
 
     it "should not store a callback when none is set in the edge" do
         @edge.callback = nil
         PSON.parse(@edge.to_pson)["callback"].should be_nil
     end
 end
 
 describe Puppet::Relationship, "when converting from pson" do
     confine "Missing 'pson' library" => Puppet.features.pson?
 
     before do
         @event = "random"
         @callback = "whatever"
         @data = {
             "source" => "mysource",
             "target" => "mytarget",
             "event" => @event,
             "callback" => @callback
         }
         @pson = {
             "type" => "Puppet::Relationship",
             "data" => @data
         }
     end
 
     def pson_result_should
         Puppet::Relationship.expects(:new).with { |*args| yield args }
     end
 
     it "should be extended with the PSON utility module" do
-        Puppet::Relationship.metaclass.ancestors.should be_include(Puppet::Util::Pson)
+        Puppet::Relationship.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
     end
 
     # LAK:NOTE For all of these tests, we convert back to the edge so we can
     # trap the actual data structure then.
     it "should pass the source in as the first argument" do
         Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget").source.should == "mysource"
     end
 
     it "should pass the target in as the second argument" do
         Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget").target.should == "mytarget"
     end
 
     it "should pass the event as an argument if it's provided" do
         Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event.should == "myevent"
     end
 
     it "should pass the callback as an argument if it's provided" do
         Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback.should == "mycallback"
     end
 end
diff --git a/spec/unit/resource.rb b/spec/unit/resource.rb
index b26f4f923..66a2b7de0 100755
--- a/spec/unit/resource.rb
+++ b/spec/unit/resource.rb
@@ -1,495 +1,495 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/resource'
 
 describe Puppet::Resource do
     [:catalog, :file, :line].each do |attr|
         it "should have an #{attr} attribute" do
             resource = Puppet::Resource.new("file", "/my/file")
             resource.should respond_to(attr)
             resource.should respond_to(attr.to_s + "=")
         end
     end
 
     describe "when initializing" do
         it "should require the type and title" do
             lambda { Puppet::Resource.new }.should raise_error(ArgumentError)
         end
 
         it "should create a resource reference with its type and title" do
             ref = Puppet::Resource::Reference.new("file", "/f")
             Puppet::Resource::Reference.expects(:new).with("file", "/f").returns ref
             Puppet::Resource.new("file", "/f")
         end
 
         it "should allow setting of parameters" do
             Puppet::Resource.new("file", "/f", :noop => true)[:noop].should be_true
         end
 
         it "should tag itself with its type" do
             Puppet::Resource.new("file", "/f").should be_tagged("file")
         end
 
         it "should tag itself with its title if the title is a valid tag" do
             Puppet::Resource.new("file", "bar").should be_tagged("bar")
         end
 
         it "should not tag itself with its title if the title is a not valid tag" do
             Puppet::Resource.new("file", "/bar").should_not be_tagged("/bar")
         end
     end
 
     it "should use the resource reference to determine its type" do
         ref = Puppet::Resource::Reference.new("file", "/f")
         Puppet::Resource::Reference.expects(:new).returns ref
         resource = Puppet::Resource.new("file", "/f")
         ref.expects(:type).returns "mytype"
         resource.type.should == "mytype"
     end
 
     it "should use its resource reference to determine its title" do
         ref = Puppet::Resource::Reference.new("file", "/f")
         Puppet::Resource::Reference.expects(:new).returns ref
         resource = Puppet::Resource.new("file", "/f")
         ref.expects(:title).returns "mytitle"
         resource.title.should == "mytitle"
     end
 
     it "should use its resource reference to determine whether it is builtin" do
         ref = Puppet::Resource::Reference.new("file", "/f")
         Puppet::Resource::Reference.expects(:new).returns ref
         resource = Puppet::Resource.new("file", "/f")
         ref.expects(:builtin_type?).returns "yep"
         resource.builtin_type?.should == "yep"
     end
 
     it "should call its builtin_type? method when 'builtin?' is called" do
         resource = Puppet::Resource.new("file", "/f")
         resource.expects(:builtin_type?).returns "foo"
         resource.builtin?.should == "foo"
     end
 
     it "should use its resource reference to produce its canonical reference string" do
         ref = Puppet::Resource::Reference.new("file", "/f")
         Puppet::Resource::Reference.expects(:new).returns ref
         resource = Puppet::Resource.new("file", "/f")
         ref.expects(:to_s).returns "Foo[bar]"
         resource.ref.should == "Foo[bar]"
     end
 
     it "should be taggable" do
         Puppet::Resource.ancestors.should be_include(Puppet::Util::Tagging)
     end
 
     it "should have an 'exported' attribute" do
         resource = Puppet::Resource.new("file", "/f")
         resource.exported = true
         resource.exported.should == true
         resource.should be_exported
     end
 
     describe "when managing parameters" do
         before do
             @resource = Puppet::Resource.new("file", "/my/file")
         end
 
         it "should allow setting and retrieving of parameters" do
             @resource[:foo] = "bar"
             @resource[:foo].should == "bar"
         end
 
         it "should canonicalize retrieved parameter names to treat symbols and strings equivalently" do
             @resource[:foo] = "bar"
             @resource["foo"].should == "bar"
         end
 
         it "should canonicalize set parameter names to treat symbols and strings equivalently" do
             @resource["foo"] = "bar"
             @resource[:foo].should == "bar"
         end
 
         it "should set the namevar when asked to set the name" do
             Puppet::Type.type(:file).stubs(:namevar).returns :myvar
             @resource[:name] = "/foo"
             @resource[:myvar].should == "/foo"
         end
 
         it "should return the namevar when asked to return the name" do
             Puppet::Type.type(:file).stubs(:namevar).returns :myvar
             @resource[:myvar] = "/foo"
             @resource[:name].should == "/foo"
         end
 
         it "should be able to set the name for non-builtin types" do
             resource = Puppet::Resource.new(:foo, "bar")
             lambda { resource[:name] = "eh" }.should_not raise_error
         end
 
         it "should be able to return the name for non-builtin types" do
             resource = Puppet::Resource.new(:foo, "bar")
             resource[:name] = "eh"
             resource[:name].should == "eh"
         end
 
         it "should be able to iterate over parameters" do
             @resource[:foo] = "bar"
             @resource[:fee] = "bare"
             params = {}
             @resource.each do |key, value|
                 params[key] = value
             end
             params.should == {:foo => "bar", :fee => "bare"}
         end
 
         it "should include Enumerable" do
             @resource.class.ancestors.should be_include(Enumerable)
         end
 
         it "should have a method for testing whether a parameter is included" do
             @resource[:foo] = "bar"
             @resource.should be_has_key(:foo)
             @resource.should_not be_has_key(:eh)
         end
 
         it "should have a method for providing the list of parameters" do
             @resource[:foo] = "bar"
             @resource[:bar] = "foo"
             keys = @resource.keys
             keys.should be_include(:foo)
             keys.should be_include(:bar)
         end
 
         it "should have a method for providing the number of parameters" do
             @resource[:foo] = "bar"
             @resource.length.should == 1
         end
 
         it "should have a method for deleting parameters" do
             @resource[:foo] = "bar"
             @resource.delete(:foo)
             @resource[:foo].should be_nil
         end
 
         it "should have a method for testing whether the parameter list is empty" do
             @resource.should be_empty
             @resource[:foo] = "bar"
             @resource.should_not be_empty
         end
 
         it "should be able to produce a hash of all existing parameters" do
             @resource[:foo] = "bar"
             @resource[:fee] = "yay"
 
             hash = @resource.to_hash
             hash[:foo].should == "bar"
             hash[:fee].should == "yay"
         end
 
         it "should not provide direct access to the internal parameters hash when producing a hash" do
             hash = @resource.to_hash
             hash[:foo] = "bar"
             @resource[:foo].should be_nil
         end
 
         it "should use the title as the namevar to the hash if no namevar is present" do
             Puppet::Type.type(:file).stubs(:namevar).returns :myvar
             @resource.to_hash[:myvar].should == "/my/file"
         end
 
         it "should set :name to the title if :name is not present for non-builtin types" do
             resource = Puppet::Resource.new :foo, "bar"
             resource.to_hash[:name].should == "bar"
         end
     end
 
     describe "when serializing" do
         before do
             @resource = Puppet::Resource.new("file", "/my/file")
             @resource["one"] = "test"
             @resource["two"] = "other"
         end
 
         it "should be able to be dumped to yaml" do
             proc { YAML.dump(@resource) }.should_not raise_error
         end
 
         it "should produce an equivalent yaml object" do
             text = YAML.dump(@resource)
 
             newresource = YAML.load(text)
             newresource.title.should == @resource.title
             newresource.type.should == @resource.type
             %w{one two}.each do |param|
                 newresource[param].should == @resource[param]
             end
         end
     end
 
     describe "when converting to a RAL resource" do
         before do
             @resource = Puppet::Resource.new("file", "/my/file")
             @resource["one"] = "test"
             @resource["two"] = "other"
         end
 
         it "should use the resource type's :create method to create the resource if the resource is of a builtin type" do
             type = mock 'resource type'
             type.expects(:new).with(@resource).returns(:myresource)
             Puppet::Type.expects(:type).with(@resource.type).returns(type)
             @resource.to_ral.should == :myresource
         end
 
         it "should convert to a component instance if the resource type is not of a builtin type" do
             component = mock 'component type'
             Puppet::Type::Component.expects(:new).with(@resource).returns "meh"
 
             Puppet::Type.expects(:type).with(@resource.type).returns(nil)
             @resource.to_ral.should == "meh"
         end
     end
 
     it "should be able to convert itself to Puppet code" do
         Puppet::Resource.new("one::two", "/my/file").should respond_to(:to_manifest)
     end
 
     describe "when converting to puppet code" do
         before do
             @resource = Puppet::Resource.new("one::two", "/my/file", :noop => true, :foo => %w{one two})
         end
 
         it "should print the type and title" do
             @resource.to_manifest.should be_include("one::two { '/my/file':\n")
         end
 
         it "should print each parameter, with the value single-quoted" do
             @resource.to_manifest.should be_include("    noop => 'true'")
         end
 
         it "should print array values appropriately" do
             @resource.to_manifest.should be_include("    foo => ['one','two']")
         end
     end
 
     it "should be able to convert itself to a TransObject instance" do
         Puppet::Resource.new("one::two", "/my/file").should respond_to(:to_trans)
     end
 
     describe "when converting to a TransObject" do
         describe "and the resource is not an instance of a builtin type" do
             before do
                 @resource = Puppet::Resource.new("foo", "bar")
             end
 
             it "should return a simple TransBucket if it is not an instance of a builtin type" do
                 bucket = @resource.to_trans
                 bucket.should be_instance_of(Puppet::TransBucket)
                 bucket.type.should == @resource.type
                 bucket.name.should == @resource.title
             end
 
             it "should copy over the resource's file" do
                 @resource.file = "/foo/bar"
                 @resource.to_trans.file.should == "/foo/bar"
             end
 
             it "should copy over the resource's line" do
                 @resource.line = 50
                 @resource.to_trans.line.should == 50
             end
         end
 
         describe "and the resource is an instance of a builtin type" do
             before do
                 @resource = Puppet::Resource.new("file", "bar")
             end
 
             it "should return a TransObject if it is an instance of a builtin resource type" do
                 trans = @resource.to_trans
                 trans.should be_instance_of(Puppet::TransObject)
                 trans.type.should == "file"
                 trans.name.should == @resource.title
             end
 
             it "should copy over the resource's file" do
                 @resource.file = "/foo/bar"
                 @resource.to_trans.file.should == "/foo/bar"
             end
 
             it "should copy over the resource's line" do
                 @resource.line = 50
                 @resource.to_trans.line.should == 50
             end
 
             # Only TransObjects support tags, annoyingly
             it "should copy over the resource's tags" do
                 @resource.tag "foo"
                 @resource.to_trans.tags.should == @resource.tags
             end
 
             it "should copy the resource's parameters into the transobject and convert the parameter name to a string" do
                 @resource[:foo] = "bar"
                 @resource.to_trans["foo"].should == "bar"
             end
 
             it "should be able to copy arrays of values" do
                 @resource[:foo] = %w{yay fee}
                 @resource.to_trans["foo"].should == %w{yay fee}
             end
 
             it "should reduce single-value arrays to just a value" do
                 @resource[:foo] = %w{yay}
                 @resource.to_trans["foo"].should == "yay"
             end
 
             it "should convert resource references into the backward-compatible form" do
                 @resource[:foo] = Puppet::Resource::Reference.new(:file, "/f")
                 @resource.to_trans["foo"].should == %w{file /f}
             end
 
             it "should convert resource references into the backward-compatible form even when within arrays" do
                 @resource[:foo] = ["a", Puppet::Resource::Reference.new(:file, "/f")]
                 @resource.to_trans["foo"].should == ["a", %w{file /f}]
             end
         end
     end
 
     describe "when converting to pson" do
         confine "Missing 'pson' library" => Puppet.features.pson?
 
         def pson_output_should
             @resource.class.expects(:pson_create).with { |hash| yield hash }
         end
 
         it "should include the pson util module" do
-            Puppet::Resource.metaclass.ancestors.should be_include(Puppet::Util::Pson)
+            Puppet::Resource.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
         end
 
         # LAK:NOTE For all of these tests, we convert back to the resource so we can
         # trap the actual data structure then.
 
         it "should set its type to the provided type" do
             Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type.should == "File"
         end
 
         it "should set its title to the provided title" do
             Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title.should == "/foo"
         end
 
         it "should include all tags from the resource" do
             resource = Puppet::Resource.new("File", "/foo")
             resource.tag("yay")
 
             Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).tags.should == resource.tags
         end
 
         it "should include the file if one is set" do
             resource = Puppet::Resource.new("File", "/foo")
             resource.file = "/my/file"
 
             Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).file.should == "/my/file"
         end
 
         it "should include the line if one is set" do
             resource = Puppet::Resource.new("File", "/foo")
             resource.line = 50
 
             Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).line.should == 50
         end
 
         it "should include the 'exported' value if one is set" do
             resource = Puppet::Resource.new("File", "/foo")
             resource.exported = true
 
             Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_true
         end
 
         it "should set 'exported' to false if no value is set" do
             resource = Puppet::Resource.new("File", "/foo")
 
             Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_false
         end
 
         it "should set all of its parameters as the 'parameters' entry" do
             resource = Puppet::Resource.new("File", "/foo")
             resource[:foo] = %w{bar eh}
             resource[:fee] = %w{baz}
 
             result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
             result["foo"].should == %w{bar eh}
             result["fee"].should == %w{baz}
         end
     end
 
     describe "when converting from pson" do
         confine "Missing 'pson' library" => Puppet.features.pson?
 
         def pson_result_should
             Puppet::Resource.expects(:new).with { |hash| yield hash }
         end
 
         before do
             @data = {
                 'type' => "file",
                 'title' => "yay",
             }
         end
 
         it "should set its type to the provided type" do
             Puppet::Resource.from_pson(@data).type.should == "File"
         end
 
         it "should set its title to the provided title" do
             Puppet::Resource.from_pson(@data).title.should == "yay"
         end
 
         it "should tag the resource with any provided tags" do
             @data['tags'] = %w{foo bar}
             resource = Puppet::Resource.from_pson(@data)
             resource.tags.should be_include("foo")
             resource.tags.should be_include("bar")
         end
 
         it "should set its file to the provided file" do
             @data['file'] = "/foo/bar"
             Puppet::Resource.from_pson(@data).file.should == "/foo/bar"
         end
 
         it "should set its line to the provided line" do
             @data['line'] = 50
             Puppet::Resource.from_pson(@data).line.should == 50
         end
 
         it "should 'exported' to true if set in the pson data" do
             @data['exported'] = true
             Puppet::Resource.from_pson(@data).exported.should be_true
         end
 
         it "should 'exported' to false if not set in the pson data" do
             Puppet::Resource.from_pson(@data).exported.should be_false
         end
 
         it "should fail if no title is provided" do
             @data.delete('title')
             lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
         end
 
         it "should fail if no type is provided" do
             @data.delete('type')
             lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
         end
 
         it "should set each of the provided parameters" do
             @data['parameters'] = {'foo' => %w{one two}, 'fee' => %w{three four}}
             resource = Puppet::Resource.from_pson(@data)
             resource['foo'].should == %w{one two}
             resource['fee'].should == %w{three four}
         end
 
         it "should convert single-value array parameters to normal values" do
             @data['parameters'] = {'foo' => %w{one}}
             resource = Puppet::Resource.from_pson(@data)
             resource['foo'].should == %w{one}
         end
     end
 end
diff --git a/spec/unit/resource/catalog.rb b/spec/unit/resource/catalog.rb
index 7583c015c..39ddccd9b 100755
--- a/spec/unit/resource/catalog.rb
+++ b/spec/unit/resource/catalog.rb
@@ -1,1053 +1,1053 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Resource::Catalog, "when compiling" do
     it "should be an Expirer" do
         Puppet::Resource::Catalog.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
     end
 
     it "should always be expired if it's not applying" do
         @catalog = Puppet::Resource::Catalog.new("host")
         @catalog.expects(:applying?).returns false
         @catalog.should be_dependent_data_expired(Time.now)
     end
 
     it "should not be expired if it's applying and the timestamp is late enough" do
         @catalog = Puppet::Resource::Catalog.new("host")
         @catalog.expire
         @catalog.expects(:applying?).returns true
         @catalog.should_not be_dependent_data_expired(Time.now)
     end
 
     it "should be able to write its list of classes to the class file" do
         @catalog = Puppet::Resource::Catalog.new("host")
 
         @catalog.add_class "foo", "bar"
 
         Puppet.settings.expects(:value).with(:classfile).returns "/class/file"
 
         fh = mock 'filehandle'
         File.expects(:open).with("/class/file", "w").yields fh
 
         fh.expects(:puts).with "foo\nbar"
 
         @catalog.write_class_file
     end
 
     it "should have a client_version attribute" do
         @catalog = Puppet::Resource::Catalog.new("host")
         @catalog.client_version = 5
         @catalog.client_version.should == 5
     end
 
     it "should have a server_version attribute" do
         @catalog = Puppet::Resource::Catalog.new("host")
         @catalog.server_version = 5
         @catalog.server_version.should == 5
     end
 
     describe "when compiling" do
         it "should accept tags" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.tag("one")
             config.tags.should == %w{one}
         end
 
         it "should accept multiple tags at once" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.tag("one", "two")
             config.tags.should == %w{one two}
         end
 
         it "should convert all tags to strings" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.tag("one", :two)
             config.tags.should == %w{one two}
         end
 
         it "should tag with both the qualified name and the split name" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.tag("one::two")
             config.tags.include?("one").should be_true
             config.tags.include?("one::two").should be_true
         end
 
         it "should accept classes" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.add_class("one")
             config.classes.should == %w{one}
             config.add_class("two", "three")
             config.classes.should == %w{one two three}
         end
 
         it "should tag itself with passed class names" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.add_class("one")
             config.tags.should == %w{one}
         end
     end
 
     describe "when extracting" do
         it "should return extraction result as the method result" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.expects(:extraction_format).returns(:whatever)
             config.expects(:extract_to_whatever).returns(:result)
             config.extract.should == :result
         end
     end
 
     describe "when extracting transobjects" do
 
         def mkscope
             @parser = Puppet::Parser::Parser.new :Code => ""
             @node = Puppet::Node.new("mynode")
             @compiler = Puppet::Parser::Compiler.new(@node, @parser)
 
             # XXX This is ridiculous.
             @compiler.send(:evaluate_main)
             @scope = @compiler.topscope
         end
 
         def mkresource(type, name)
             Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope)
         end
 
         it "should always create a TransBucket for the 'main' class" do
             config = Puppet::Resource::Catalog.new("mynode")
 
             @scope = mkscope
             @source = mock 'source'
 
             main = mkresource("class", :main)
             config.add_vertex(main)
 
             bucket = stub 'bucket', :file= => nil, :line= => nil, :classes= => nil
             bucket.expects(:type=).with("Class")
             bucket.expects(:name=).with(:main)
             main.stubs(:builtin?).returns(false)
 
             Puppet::TransBucket.expects(:new).returns bucket
 
             config.extract_to_transportable.should equal(bucket)
         end
 
         # Now try it with a more complicated graph -- a three tier graph, each tier
         it "should transform arbitrarily deep graphs into isomorphic trees" do
             config = Puppet::Resource::Catalog.new("mynode")
 
             @scope = mkscope
             @scope.stubs(:tags).returns([])
             @source = mock 'source'
 
             # Create our scopes.
             top = mkresource "class", :main
             topbucket = []
             topbucket.expects(:classes=).with([])
             top.expects(:to_trans).returns(topbucket)
             topres = mkresource "file", "/top"
             topres.expects(:to_trans).returns(:topres)
             config.add_edge top, topres
 
             middle = mkresource "class", "middle"
             middle.expects(:to_trans).returns([])
             config.add_edge top, middle
             midres = mkresource "file", "/mid"
             midres.expects(:to_trans).returns(:midres)
             config.add_edge middle, midres
 
             bottom = mkresource "class", "bottom"
             bottom.expects(:to_trans).returns([])
             config.add_edge middle, bottom
             botres = mkresource "file", "/bot"
             botres.expects(:to_trans).returns(:botres)
             config.add_edge bottom, botres
 
             toparray = config.extract_to_transportable
 
             # This is annoying; it should look like:
             #   [[[:botres], :midres], :topres]
             # but we can't guarantee sort order.
             toparray.include?(:topres).should be_true
 
             midarray = toparray.find { |t| t.is_a?(Array) }
             midarray.include?(:midres).should be_true
             botarray = midarray.find { |t| t.is_a?(Array) }
             botarray.include?(:botres).should be_true
         end
     end
 
     describe " when converting to a Puppet::Resource catalog" do
         before do
             @original = Puppet::Resource::Catalog.new("mynode")
             @original.tag(*%w{one two three})
             @original.add_class *%w{four five six}
 
             @top            = Puppet::TransObject.new 'top', "class"
             @topobject      = Puppet::TransObject.new '/topobject', "file"
             @middle         = Puppet::TransObject.new 'middle', "class"
             @middleobject   = Puppet::TransObject.new '/middleobject', "file"
             @bottom         = Puppet::TransObject.new 'bottom', "class"
             @bottomobject   = Puppet::TransObject.new '/bottomobject', "file"
 
             @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
             @original.add_resource(*@resources)
 
             @original.add_edge(@top, @topobject)
             @original.add_edge(@top, @middle)
             @original.add_edge(@middle, @middleobject)
             @original.add_edge(@middle, @bottom)
             @original.add_edge(@bottom, @bottomobject)
 
             @catalog = @original.to_resource
         end
 
         it "should copy over the version" do
             @original.version = "foo"
             @original.to_resource.version.should == "foo"
         end
 
         it "should add all resources as Puppet::Resource instances" do
             @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Resource) }
         end
 
         it "should copy the tag list to the new catalog" do
             @catalog.tags.sort.should == @original.tags.sort
         end
 
         it "should copy the class list to the new catalog" do
             @catalog.classes.should == @original.classes
         end
 
         it "should duplicate the original edges" do
             @original.edges.each do |edge|
                 @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
             end
         end
 
         it "should set itself as the catalog for each converted resource" do
             @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
         end
     end
 
     describe "when converting to a RAL catalog" do
         before do
             @original = Puppet::Resource::Catalog.new("mynode")
             @original.tag(*%w{one two three})
             @original.add_class *%w{four five six}
 
             @top            = Puppet::Resource.new :class, 'top'
             @topobject      = Puppet::Resource.new :file, '/topobject'
             @middle         = Puppet::Resource.new :class, 'middle'
             @middleobject   = Puppet::Resource.new :file, '/middleobject'
             @bottom         = Puppet::Resource.new :class, 'bottom'
             @bottomobject   = Puppet::Resource.new :file, '/bottomobject'
 
             @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
             @original.add_resource(*@resources)
 
             @original.add_edge(@top, @topobject)
             @original.add_edge(@top, @middle)
             @original.add_edge(@middle, @middleobject)
             @original.add_edge(@middle, @bottom)
             @original.add_edge(@bottom, @bottomobject)
 
             @catalog = @original.to_ral
         end
 
         it "should add all resources as RAL instances" do
             @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Type) }
         end
 
         it "should copy the tag list to the new catalog" do
             @catalog.tags.sort.should == @original.tags.sort
         end
 
         it "should copy the class list to the new catalog" do
             @catalog.classes.should == @original.classes
         end
 
         it "should duplicate the original edges" do
             @original.edges.each do |edge|
                 @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
             end
         end
 
         it "should set itself as the catalog for each converted resource" do
             @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
         end
 
         # This tests #931.
         it "should not lose track of resources whose names vary" do
             changer = Puppet::TransObject.new 'changer', 'test'
 
             config = Puppet::Resource::Catalog.new('test')
             config.add_resource(changer)
             config.add_resource(@top)
 
             config.add_edge(@top, changer)
 
             resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :catalog= => nil, :remove => nil
 
             #changer is going to get duplicated as part of a fix for aliases 1094
             changer.expects(:dup).returns(changer)
             changer.expects(:to_ral).returns(resource)
 
             newconfig = nil
 
             proc { @catalog = config.to_ral }.should_not raise_error
             @catalog.resource("Test[changer2]").should equal(resource)
         end
 
         after do
             # Remove all resource instances.
             @catalog.clear(true)
         end
     end
 
     describe "when filtering" do
         before :each do
             @original = Puppet::Resource::Catalog.new("mynode")
             @original.tag(*%w{one two three})
             @original.add_class *%w{four five six}
 
             @r1 = stub_everything 'r1', :ref => "File[/a]"
             @r1.stubs(:respond_to?).with(:ref).returns(true)
             @r1.stubs(:dup).returns(@r1)
             @r1.stubs(:is_a?).returns(Puppet::Resource).returns(true)
 
             @r2 = stub_everything 'r2', :ref => "File[/b]"
             @r2.stubs(:respond_to?).with(:ref).returns(true)
             @r2.stubs(:dup).returns(@r2)
             @r2.stubs(:is_a?).returns(Puppet::Resource).returns(true)
 
             @resources = [@r1,@r2]
 
             @original.add_resource(@r1,@r2)
         end
 
         it "should transform the catalog to a resource catalog" do
             @original.expects(:to_catalog).with { |h,b| h == :to_resource }
 
             @original.filter
         end
 
         it "should scan each catalog resource in turn and apply filtering block" do
             @resources.each { |r| r.expects(:test?) }
             @original.filter do |r|
                 r.test?
             end
         end
 
         it "should filter out resources which produce true when the filter block is evaluated" do
             @original.filter do |r|
                 r == @r1
             end.resource("File[/a]").should be_nil
         end
 
         it "should not consider edges against resources that were filtered out" do
             @original.add_edge(@r1,@r2)
             @original.filter do |r|
                 r == @r1
             end.edge(@r1,@r2).should be_empty
         end
     end
 
     describe "when functioning as a resource container" do
         before do
             @catalog = Puppet::Resource::Catalog.new("host")
             @one = Puppet::Type.type(:notify).new :name => "one"
             @two = Puppet::Type.type(:notify).new :name => "two"
             @dupe = Puppet::Type.type(:notify).new :name => "one"
         end
 
         it "should provide a method to add one or more resources" do
             @catalog.add_resource @one, @two
             @catalog.resource(@one.ref).should equal(@one)
             @catalog.resource(@two.ref).should equal(@two)
         end
 
         it "should add resources to the relationship graph if it exists" do
             relgraph = @catalog.relationship_graph
             @catalog.add_resource @one
             relgraph.should be_vertex(@one)
         end
 
         it "should yield added resources if a block is provided" do
             yielded = []
             @catalog.add_resource(@one, @two) { |r| yielded << r }
             yielded.length.should == 2
         end
 
         it "should set itself as the resource's catalog if it is not a relationship graph" do
             @one.expects(:catalog=).with(@catalog)
             @catalog.add_resource @one
         end
 
         it "should make all vertices available by resource reference" do
             @catalog.add_resource(@one)
             @catalog.resource(@one.ref).should equal(@one)
             @catalog.vertices.find { |r| r.ref == @one.ref }.should equal(@one)
         end
 
         it "should canonize how resources are referred to during retrieval when both type and title are provided" do
             @catalog.add_resource(@one)
 
             @catalog.resource("notify", "one").should equal(@one)
         end
 
         it "should canonize how resources are referred to during retrieval when just the title is provided" do
             @catalog.add_resource(@one)
 
             @catalog.resource("notify[one]", nil).should equal(@one)
         end
 
         it "should not allow two resources with the same resource reference" do
             @catalog.add_resource(@one)
 
             proc { @catalog.add_resource(@dupe) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
         end
 
         it "should not store objects that do not respond to :ref" do
             proc { @catalog.add_resource("thing") }.should raise_error(ArgumentError)
         end
 
         it "should remove all resources when asked" do
             @catalog.add_resource @one
             @catalog.add_resource @two
             @one.expects :remove
             @two.expects :remove
             @catalog.clear(true)
         end
 
         it "should support a mechanism for finishing resources" do
             @one.expects :finish
             @two.expects :finish
             @catalog.add_resource @one
             @catalog.add_resource @two
 
             @catalog.finalize
         end
 
         it "should make default resources when finalizing" do
             @catalog.expects(:make_default_resources)
             @catalog.finalize
         end
 
         it "should add default resources to the catalog upon creation" do
             @catalog.make_default_resources
             @catalog.resource(:schedule, "daily").should_not be_nil
         end
 
         it "should optionally support an initialization block and should finalize after such blocks" do
             @one.expects :finish
             @two.expects :finish
             config = Puppet::Resource::Catalog.new("host") do |conf|
                 conf.add_resource @one
                 conf.add_resource @two
             end
         end
 
         it "should inform the resource that it is the resource's catalog" do
             @one.expects(:catalog=).with(@catalog)
             @catalog.add_resource @one
         end
 
         it "should be able to find resources by reference" do
             @catalog.add_resource @one
             @catalog.resource(@one.ref).should equal(@one)
         end
 
         it "should be able to find resources by reference or by type/title tuple" do
             @catalog.add_resource @one
             @catalog.resource("notify", "one").should equal(@one)
         end
 
         it "should have a mechanism for removing resources" do
             @catalog.add_resource @one
             @one.expects :remove
             @catalog.remove_resource(@one)
             @catalog.resource(@one.ref).should be_nil
             @catalog.vertex?(@one).should be_false
         end
 
         it "should have a method for creating aliases for resources" do
             @catalog.add_resource @one
             @catalog.alias(@one, "other")
             @catalog.resource("notify", "other").should equal(@one)
         end
 
         it "should ignore conflicting aliases that point to the aliased resource" do
             @catalog.alias(@one, "other")
             lambda { @catalog.alias(@one, "other") }.should_not raise_error
         end
 
         it "should create aliases for resources isomorphic resources whose names do not match their titles" do
             resource = Puppet::Type::File.new(:title => "testing", :path => "/something")
 
             @catalog.add_resource(resource)
 
             @catalog.resource(:file, "/something").should equal(resource)
         end
 
         it "should not create aliases for resources non-isomorphic resources whose names do not match their titles" do
             resource = Puppet::Type.type(:exec).new(:title => "testing", :command => "echo", :path => %w{/bin /usr/bin /usr/local/bin})
 
             @catalog.add_resource(resource)
 
             # Yay, I've already got a 'should' method
             @catalog.resource(:exec, "echo").object_id.should == nil.object_id
         end
 
         # This test is the same as the previous, but the behaviour should be explicit.
         it "should alias using the class name from the resource reference, not the resource class name" do
             @catalog.add_resource @one
             @catalog.alias(@one, "other")
             @catalog.resource("notify", "other").should equal(@one)
         end
 
         it "should ignore conflicting aliases that point to the aliased resource" do
             @catalog.alias(@one, "other")
             lambda { @catalog.alias(@one, "other") }.should_not raise_error
         end
 
         it "should fail to add an alias if the aliased name already exists" do
             @catalog.add_resource @one
             proc { @catalog.alias @two, "one" }.should raise_error(ArgumentError)
         end
 
         it "should not fail when a resource has duplicate aliases created" do
             @catalog.add_resource @one
             proc { @catalog.alias @one, "one" }.should_not raise_error
         end
 
         it "should not create aliases that point back to the resource" do
             @catalog.alias(@one, "one")
             @catalog.resource(:notify, "one").should be_nil
         end
 
         it "should be able to look resources up by their aliases" do
             @catalog.add_resource @one
             @catalog.alias @one, "two"
             @catalog.resource(:notify, "two").should equal(@one)
         end
 
         it "should remove resource aliases when the target resource is removed" do
             @catalog.add_resource @one
             @catalog.alias(@one, "other")
             @one.expects :remove
             @catalog.remove_resource(@one)
             @catalog.resource("notify", "other").should be_nil
         end
 
         it "should add an alias for the namevar when the title and name differ on isomorphic resource types" do
             resource = Puppet::Type.type(:file).new :path => "/something", :title => "other", :content => "blah"
             resource.expects(:isomorphic?).returns(true)
             @catalog.add_resource(resource)
             @catalog.resource(:file, "other").should equal(resource)
             @catalog.resource(:file, "/something").ref.should == resource.ref
         end
 
         it "should not add an alias for the namevar when the title and name differ on non-isomorphic resource types" do
             resource = Puppet::Type.type(:file).new :path => "/something", :title => "other", :content => "blah"
             resource.expects(:isomorphic?).returns(false)
             @catalog.add_resource(resource)
             @catalog.resource(:file, resource.title).should equal(resource)
             # We can't use .should here, because the resources respond to that method.
             if @catalog.resource(:file, resource.name)
                 raise "Aliased non-isomorphic resource"
             end
         end
 
         it "should provide a method to create additional resources that also registers the resource" do
             args = {:name => "/yay", :ensure => :file}
             resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay"
             Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
             @catalog.create_resource :file, args
             @catalog.resource("File[/yay]").should equal(resource)
         end
     end
 
     describe "when applying" do
         before :each do
             @catalog = Puppet::Resource::Catalog.new("host")
 
             @catalog.retrieval_duration = Time.now
             @transaction = mock 'transaction'
             Puppet::Transaction.stubs(:new).returns(@transaction)
             @transaction.stubs(:evaluate)
             @transaction.stubs(:addtimes)
         end
 
         it "should create and evaluate a transaction" do
             @transaction.expects(:evaluate)
             @catalog.apply
         end
 
         it "should provide the catalog time to the transaction" do
             @transaction.expects(:addtimes).with do |arg|
                 arg[:config_retrieval].should be_instance_of(Time)
                 true
             end
             @catalog.apply
         end
 
         it "should return the transaction" do
             @catalog.apply.should equal(@transaction)
         end
 
         it "should yield the transaction if a block is provided" do
             @catalog.apply do |trans|
                 trans.should equal(@transaction)
             end
         end
 
         it "should default to not being a host catalog" do
             @catalog.host_config.should be_nil
         end
 
         it "should pass supplied tags on to the transaction" do
             @transaction.expects(:tags=).with(%w{one two})
             @catalog.apply(:tags => %w{one two})
         end
 
         it "should set ignoreschedules on the transaction if specified in apply()" do
             @transaction.expects(:ignoreschedules=).with(true)
             @catalog.apply(:ignoreschedules => true)
         end
 
         it "should expire cached data in the resources both before and after the transaction" do
             @catalog.expects(:expire).times(2)
             @catalog.apply
         end
 
         describe "host catalogs" do
 
             # super() doesn't work in the setup method for some reason
             before do
                 @catalog.host_config = true
                 Puppet::Util::Storage.stubs(:store)
             end
 
             it "should send a report if reporting is enabled" do
                 Puppet[:report] = true
                 @transaction.expects :send_report
                 @transaction.stubs :any_failed? => false
                 @catalog.apply
             end
 
             it "should send a report if report summaries are enabled" do
                 Puppet[:summarize] = true
                 @transaction.expects :send_report
                 @transaction.stubs :any_failed? => false
                 @catalog.apply
             end
 
             it "should initialize the state database before applying a catalog" do
                 Puppet::Util::Storage.expects(:load)
 
                 # Short-circuit the apply, so we know we're loading before the transaction
                 Puppet::Transaction.expects(:new).raises ArgumentError
                 proc { @catalog.apply }.should raise_error(ArgumentError)
             end
 
             it "should sync the state database after applying" do
                 Puppet::Util::Storage.expects(:store)
                 @transaction.stubs :any_failed? => false
                 @catalog.apply
             end
 
             after { Puppet.settings.clear }
         end
 
         describe "non-host catalogs" do
 
             before do
                 @catalog.host_config = false
             end
 
             it "should never send reports" do
                 Puppet[:report] = true
                 Puppet[:summarize] = true
                 @transaction.expects(:send_report).never
                 @catalog.apply
             end
 
             it "should never modify the state database" do
                 Puppet::Util::Storage.expects(:load).never
                 Puppet::Util::Storage.expects(:store).never
                 @catalog.apply
             end
 
             after { Puppet.settings.clear }
         end
     end
 
     describe "when creating a relationship graph" do
         before do
             Puppet::Type.type(:component)
             @catalog = Puppet::Resource::Catalog.new("host")
             @compone = Puppet::Type::Component.new :name => "one"
             @comptwo = Puppet::Type::Component.new :name => "two", :require => "Class[one]"
             @file = Puppet::Type.type(:file)
             @one = @file.new :path => "/one"
             @two = @file.new :path => "/two"
             @sub = @file.new :path => "/two/subdir"
             @catalog.add_edge @compone, @one
             @catalog.add_edge @comptwo, @two
 
             @three = @file.new :path => "/three"
             @four = @file.new :path => "/four", :require => "File[/three]"
             @five = @file.new :path => "/five"
             @catalog.add_resource @compone, @comptwo, @one, @two, @three, @four, @five, @sub
 
             @relationships = @catalog.relationship_graph
         end
 
         it "should be able to create a relationship graph" do
             @relationships.should be_instance_of(Puppet::SimpleGraph)
         end
 
         it "should not have any components" do
             @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil
         end
 
         it "should have all non-component resources from the catalog" do
             # The failures print out too much info, so i just do a class comparison
             @relationships.vertex?(@five).should be_true
         end
 
         it "should have all resource relationships set as edges" do
             @relationships.edge?(@three, @four).should be_true
         end
 
         it "should copy component relationships to all contained resources" do
             @relationships.edge?(@one, @two).should be_true
         end
 
         it "should add automatic relationships to the relationship graph" do
             @relationships.edge?(@two, @sub).should be_true
         end
 
         it "should get removed when the catalog is cleaned up" do
             @relationships.expects(:clear)
             @catalog.clear
             @catalog.instance_variable_get("@relationship_graph").should be_nil
         end
 
         it "should write :relationships and :expanded_relationships graph files if the catalog is a host catalog" do
             @catalog.clear
             graph = Puppet::SimpleGraph.new
             Puppet::SimpleGraph.expects(:new).returns graph
 
             graph.expects(:write_graph).with(:relationships)
             graph.expects(:write_graph).with(:expanded_relationships)
 
             @catalog.host_config = true
 
             @catalog.relationship_graph
         end
 
         it "should not write graph files if the catalog is not a host catalog" do
             @catalog.clear
             graph = Puppet::SimpleGraph.new
             Puppet::SimpleGraph.expects(:new).returns graph
 
             graph.expects(:write_graph).never
 
             @catalog.host_config = false
 
             @catalog.relationship_graph
         end
 
         it "should create a new relationship graph after clearing the old one" do
             @relationships.expects(:clear)
             @catalog.clear
             @catalog.relationship_graph.should be_instance_of(Puppet::SimpleGraph)
         end
 
         it "should remove removed resources from the relationship graph if it exists" do
             @catalog.remove_resource(@one)
             @catalog.relationship_graph.vertex?(@one).should be_false
         end
     end
 
     describe "when writing dot files" do
         before do
             @catalog = Puppet::Resource::Catalog.new("host")
             @name = :test
             @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
         end
 
         it "should only write when it is a host catalog" do
             File.expects(:open).with(@file).never
             @catalog.host_config = false
             Puppet[:graph] = true
             @catalog.write_graph(@name)
         end
 
         after do
             Puppet.settings.clear
         end
     end
 
     describe "when indirecting" do
         before do
             @real_indirection = Puppet::Resource::Catalog.indirection
 
             @indirection = stub 'indirection', :name => :catalog
 
             Puppet::Util::Cacher.expire
         end
 
         it "should redirect to the indirection for retrieval" do
             Puppet::Resource::Catalog.stubs(:indirection).returns(@indirection)
             @indirection.expects(:find)
             Puppet::Resource::Catalog.find(:myconfig)
         end
 
         it "should use the value of the 'catalog_terminus' setting to determine its terminus class" do
             # Puppet only checks the terminus setting the first time you ask
             # so this returns the object to the clean state
             # at the expense of making this test less pure
             Puppet::Resource::Catalog.indirection.reset_terminus_class
 
             Puppet.settings[:catalog_terminus] = "rest"
             Puppet::Resource::Catalog.indirection.terminus_class.should == :rest
         end
 
         it "should allow the terminus class to be set manually" do
             Puppet::Resource::Catalog.indirection.terminus_class = :rest
             Puppet::Resource::Catalog.indirection.terminus_class.should == :rest
         end
 
         after do
             Puppet::Util::Cacher.expire
             @real_indirection.reset_terminus_class
         end
     end
 
     describe "when converting to yaml" do
         before do
             @catalog = Puppet::Resource::Catalog.new("me")
             @catalog.add_edge("one", "two")
         end
 
         it "should be able to be dumped to yaml" do
             YAML.dump(@catalog).should be_instance_of(String)
         end
     end
 
     describe "when converting from yaml" do
         before do
             @catalog = Puppet::Resource::Catalog.new("me")
             @catalog.add_edge("one", "two")
 
             text = YAML.dump(@catalog)
             @newcatalog = YAML.load(text)
         end
 
         it "should get converted back to a catalog" do
             @newcatalog.should be_instance_of(Puppet::Resource::Catalog)
         end
 
         it "should have all vertices" do
             @newcatalog.vertex?("one").should be_true
             @newcatalog.vertex?("two").should be_true
         end
 
         it "should have all edges" do
             @newcatalog.edge?("one", "two").should be_true
         end
     end
 end
 
 describe Puppet::Resource::Catalog, "when converting to pson" do
     confine "Missing 'pson' library" => Puppet.features.pson?
 
     before do
         @catalog = Puppet::Resource::Catalog.new("myhost")
     end
 
     def pson_output_should
         @catalog.class.expects(:pson_create).with { |hash| yield hash }.returns(:something)
     end
 
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
     it "should set its document_type to 'Catalog'" do
         pson_output_should { |hash| hash['document_type'] == "Catalog" }
 
         PSON.parse @catalog.to_pson
     end
 
     it "should set its data as a hash" do
         pson_output_should { |hash| hash['data'].is_a?(Hash) }
         PSON.parse @catalog.to_pson
     end
 
     [:name, :version, :tags, :classes].each do |param|
         it "should set its #{param} to the #{param} of the resource" do
             @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
 
             pson_output_should { |hash| hash['data'][param.to_s] == @catalog.send(param) }
             PSON.parse @catalog.to_pson
         end
     end
 
     it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
         one = stub 'one', :to_pson_data_hash => "one_resource", :ref => "Foo[one]"
         two = stub 'two', :to_pson_data_hash => "two_resource", :ref => "Foo[two]"
 
         @catalog.add_resource(one)
         @catalog.add_resource(two)
 
         # TODO this should really guarantee sort order
         PSON.parse(@catalog.to_pson,:create_additions => false)['data']['resources'].sort.should == ["one_resource", "two_resource"].sort
 
     end
 
     it "should convert its edges to a PSON-encoded array and store it as the 'edges' data" do
         one   = stub 'one',   :to_pson_data_hash => "one_resource",   :ref => 'Foo[one]'
         two   = stub 'two',   :to_pson_data_hash => "two_resource",   :ref => 'Foo[two]'
         three = stub 'three', :to_pson_data_hash => "three_resource", :ref => 'Foo[three]'
 
         @catalog.add_edge(one, two)
         @catalog.add_edge(two, three)
 
         @catalog.edge(one, two  ).expects(:to_pson_data_hash).returns "one_two_pson"
         @catalog.edge(two, three).expects(:to_pson_data_hash).returns "two_three_pson"
 
         PSON.parse(@catalog.to_pson,:create_additions => false)['data']['edges'].sort.should == %w{one_two_pson two_three_pson}.sort
     end
 end
 
 describe Puppet::Resource::Catalog, "when converting from pson" do
     confine "Missing 'pson' library" => Puppet.features.pson?
 
     def pson_result_should
         Puppet::Resource::Catalog.expects(:new).with { |hash| yield hash }
     end
 
     before do
         @data = {
             'name' => "myhost"
         }
         @pson = {
             'document_type' => 'Puppet::Resource::Catalog',
             'data' => @data,
             'metadata' => {}
         }
 
         @catalog = Puppet::Resource::Catalog.new("myhost")
         Puppet::Resource::Catalog.stubs(:new).returns @catalog
     end
 
     it "should be extended with the PSON utility module" do
-        Puppet::Resource::Catalog.metaclass.ancestors.should be_include(Puppet::Util::Pson)
+        Puppet::Resource::Catalog.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
     end
 
     it "should create it with the provided name" do
         Puppet::Resource::Catalog.expects(:new).with('myhost').returns @catalog
         PSON.parse @pson.to_pson
     end
 
     it "should set the provided version on the catalog if one is set" do
         @data['version'] = 50
         PSON.parse @pson.to_pson
         @catalog.version.should == @data['version']
     end
 
     it "should set any provided tags on the catalog" do
         @data['tags'] = %w{one two}
         PSON.parse @pson.to_pson
         @catalog.tags.should == @data['tags']
     end
 
     it "should set any provided classes on the catalog" do
         @data['classes'] = %w{one two}
         PSON.parse @pson.to_pson
         @catalog.classes.should == @data['classes']
     end
 
     it 'should convert the resources list into resources and add each of them' do
         @data['resources'] = [Puppet::Resource.new(:file, "/foo"), Puppet::Resource.new(:file, "/bar")]
 
         @catalog.expects(:add_resource).times(2).with { |res| res.type == "File" }
         PSON.parse @pson.to_pson
     end
 
     it 'should convert resources even if they do not include "type" information' do
         @data['resources'] = [Puppet::Resource.new(:file, "/foo")]
 
         @data['resources'][0].expects(:to_pson).returns '{"title":"/foo","tags":["file"],"type":"File"}'
 
         @catalog.expects(:add_resource).with { |res| res.type == "File" }
 
         PSON.parse @pson.to_pson
     end
 
     it 'should convert the edges list into edges and add each of them' do
         one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
         two = Puppet::Relationship.new("tsource", "ttarget", :event => "two", :callback => "refresh")
 
         @data['edges'] = [one, two]
 
         @catalog.stubs(:resource).returns("eh")
 
         @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
         @catalog.expects(:add_edge).with { |edge| edge.event == "two" }
 
         PSON.parse @pson.to_pson
     end
 
     it "should be able to convert relationships that do not include 'type' information" do
         one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
         one.expects(:to_pson).returns "{\"event\":\"one\",\"callback\":\"refresh\",\"source\":\"osource\",\"target\":\"otarget\"}"
 
         @data['edges'] = [one]
 
         @catalog.stubs(:resource).returns("eh")
 
         @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
 
         PSON.parse @pson.to_pson
     end
 
     it "should set the source and target for each edge to the actual resource" do
         edge = Puppet::Relationship.new("source", "target")
 
         @data['edges'] = [edge]
 
         @catalog.expects(:resource).with("source").returns("source_resource")
         @catalog.expects(:resource).with("target").returns("target_resource")
 
         @catalog.expects(:add_edge).with { |edge| edge.source == "source_resource" and edge.target == "target_resource" }
 
         PSON.parse @pson.to_pson
     end
 
     it "should fail if the source resource cannot be found" do
         edge = Puppet::Relationship.new("source", "target")
 
         @data['edges'] = [edge]
 
         @catalog.expects(:resource).with("source").returns(nil)
         @catalog.stubs(:resource).with("target").returns("target_resource")
 
         lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
     end
 
     it "should fail if the target resource cannot be found" do
         edge = Puppet::Relationship.new("source", "target")
 
         @data['edges'] = [edge]
 
         @catalog.stubs(:resource).with("source").returns("source_resource")
         @catalog.expects(:resource).with("target").returns(nil)
 
         lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
     end
 end
diff --git a/spec/unit/ssl/certificate.rb b/spec/unit/ssl/certificate.rb
index 0d48991ad..6bd7e77f5 100755
--- a/spec/unit/ssl/certificate.rb
+++ b/spec/unit/ssl/certificate.rb
@@ -1,124 +1,124 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/ssl/certificate'
 
 describe Puppet::SSL::Certificate do
     before do
         @class = Puppet::SSL::Certificate
     end
 
     after do
         @class.instance_variable_set("@ca_location", nil)
     end
 
     it "should be extended with the Indirector module" do
-        @class.metaclass.should be_include(Puppet::Indirector)
+        @class.singleton_class.should be_include(Puppet::Indirector)
     end
 
     it "should indirect certificate" do
         @class.indirection.name.should == :certificate
     end
 
     it "should only support the text format" do
         @class.supported_formats.should == [:s]
     end
 
     describe "when converting from a string" do
         it "should create a certificate instance with its name set to the certificate subject and its content set to the extracted certificate" do
             cert = stub 'certificate', :subject => "/CN=Foo.madstop.com"
             OpenSSL::X509::Certificate.expects(:new).with("my certificate").returns(cert)
 
             mycert = stub 'sslcert'
             mycert.expects(:content=).with(cert)
 
             @class.expects(:new).with("foo.madstop.com").returns mycert
 
             @class.from_s("my certificate")
         end
 
         it "should create multiple certificate instances when asked" do
             cert1 = stub 'cert1'
             @class.expects(:from_s).with("cert1").returns cert1
             cert2 = stub 'cert2'
             @class.expects(:from_s).with("cert2").returns cert2
 
             @class.from_multiple_s("cert1\n---\ncert2").should == [cert1, cert2]
         end
     end
 
     describe "when converting to a string" do
         before do
             @certificate = @class.new("myname")
         end
 
         it "should return an empty string when it has no certificate" do
             @certificate.to_s.should == ""
         end
 
         it "should convert the certificate to pem format" do
             certificate = mock 'certificate', :to_pem => "pem"
             @certificate.content = certificate
             @certificate.to_s.should == "pem"
         end
 
         it "should be able to convert multiple instances to a string" do
             cert2 = @class.new("foo")
             @certificate.expects(:to_s).returns "cert1"
             cert2.expects(:to_s).returns "cert2"
 
             @class.to_multiple_s([@certificate, cert2]).should == "cert1\n---\ncert2"
 
         end
     end
 
     describe "when managing instances" do
         before do
             @certificate = @class.new("myname")
         end
 
         it "should have a name attribute" do
             @certificate.name.should == "myname"
         end
 
         it "should convert its name to a string and downcase it" do
             @class.new(:MyName).name.should == "myname"
         end
 
         it "should have a content attribute" do
             @certificate.should respond_to(:content)
         end
 
         it "should return a nil expiration if there is no actual certificate" do
             @certificate.stubs(:content).returns nil
 
             @certificate.expiration.should be_nil
         end
 
         it "should use the expiration of the certificate as its expiration date" do
             cert = stub 'cert'
             @certificate.stubs(:content).returns cert
 
             cert.expects(:not_after).returns "sometime"
 
             @certificate.expiration.should == "sometime"
         end
 
         it "should be able to read certificates from disk" do
             path = "/my/path"
             File.expects(:read).with(path).returns("my certificate")
             certificate = mock 'certificate'
             OpenSSL::X509::Certificate.expects(:new).with("my certificate").returns(certificate)
             @certificate.read(path).should equal(certificate)
             @certificate.content.should equal(certificate)
         end
 
         it "should have a :to_text method that it delegates to the actual key" do
             real_certificate = mock 'certificate'
             real_certificate.expects(:to_text).returns "certificatetext"
             @certificate.content = real_certificate
             @certificate.to_text.should == "certificatetext"
         end
     end
 end
diff --git a/spec/unit/ssl/certificate_request.rb b/spec/unit/ssl/certificate_request.rb
index 85e1d5470..fa5986a48 100755
--- a/spec/unit/ssl/certificate_request.rb
+++ b/spec/unit/ssl/certificate_request.rb
@@ -1,193 +1,193 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/ssl/certificate_request'
 require 'puppet/ssl/key'
 
 describe Puppet::SSL::CertificateRequest do
     before do
         @class = Puppet::SSL::CertificateRequest
     end
 
     it "should be extended with the Indirector module" do
-        @class.metaclass.should be_include(Puppet::Indirector)
+        @class.singleton_class.should be_include(Puppet::Indirector)
     end
 
     it "should indirect certificate_request" do
         @class.indirection.name.should == :certificate_request
     end
 
     it "should use any provided name as its name" do
         @class.new("myname").name.should == "myname"
     end
 
     it "should only support the text format" do
         @class.supported_formats.should == [:s]
     end
 
     describe "when converting from a string" do
         it "should create a CSR instance with its name set to the CSR subject and its content set to the extracted CSR" do
             csr = stub 'csr', :subject => "/CN=Foo.madstop.com"
             OpenSSL::X509::Request.expects(:new).with("my csr").returns(csr)
 
             mycsr = stub 'sslcsr'
             mycsr.expects(:content=).with(csr)
 
             @class.expects(:new).with("foo.madstop.com").returns mycsr
 
             @class.from_s("my csr")
         end
     end
 
     describe "when managing instances" do
         before do
             @request = @class.new("myname")
         end
 
         it "should have a name attribute" do
             @request.name.should == "myname"
         end
 
         it "should downcase its name" do
             @class.new("MyName").name.should == "myname"
         end
 
         it "should have a content attribute" do
             @request.should respond_to(:content)
         end
 
         it "should be able to read requests from disk" do
             path = "/my/path"
             File.expects(:read).with(path).returns("my request")
             request = mock 'request'
             OpenSSL::X509::Request.expects(:new).with("my request").returns(request)
             @request.read(path).should equal(request)
             @request.content.should equal(request)
         end
 
         it "should return an empty string when converted to a string with no request" do
             @request.to_s.should == ""
         end
 
         it "should convert the request to pem format when converted to a string" do
             request = mock 'request', :to_pem => "pem"
             @request.content = request
             @request.to_s.should == "pem"
         end
 
         it "should have a :to_text method that it delegates to the actual key" do
             real_request = mock 'request'
             real_request.expects(:to_text).returns "requesttext"
             @request.content = real_request
             @request.to_text.should == "requesttext"
         end
     end
 
     describe "when generating" do
         before do
             @instance = @class.new("myname")
 
             key = Puppet::SSL::Key.new("myname")
             @key = key.generate
 
             @request = OpenSSL::X509::Request.new
             OpenSSL::X509::Request.expects(:new).returns(@request)
 
             @request.stubs(:verify).returns(true)
         end
 
         it "should use the content of the provided key if the key is a Puppet::SSL::Key instance" do
             key = Puppet::SSL::Key.new("test")
             key.expects(:content).returns @key
 
             @request.expects(:sign).with{ |key, digest| key == @key }
             @instance.generate(key)
         end
 
         it "should log that it is creating a new certificate request" do
             Puppet.expects(:info)
             @instance.generate(@key)
         end
 
         it "should set the subject to [CN, name]" do
             subject = mock 'subject'
             OpenSSL::X509::Name.expects(:new).with([["CN", @instance.name]]).returns(subject)
             @request.expects(:subject=).with(subject)
             @instance.generate(@key)
         end
 
         it "should set the version to 0" do
             @request.expects(:version=).with(0)
             @instance.generate(@key)
         end
 
         it "should set the public key to the provided key's public key" do
             # Yay, the private key extracts a new key each time.
             pubkey = @key.public_key
             @key.stubs(:public_key).returns pubkey
             @request.expects(:public_key=).with(@key.public_key)
             @instance.generate(@key)
         end
 
         it "should sign the csr with the provided key and a digest" do
             digest = mock 'digest'
             OpenSSL::Digest::MD5.expects(:new).returns(digest)
             @request.expects(:sign).with(@key, digest)
             @instance.generate(@key)
         end
 
         it "should verify the generated request using the public key" do
             # Stupid keys don't have a competent == method.
             @request.expects(:verify).with { |public_key| public_key.to_s == @key.public_key.to_s }.returns true
             @instance.generate(@key)
         end
 
         it "should fail if verification fails" do
             @request.expects(:verify).returns false
 
             lambda { @instance.generate(@key) }.should raise_error(Puppet::Error)
         end
 
         it "should return the generated request" do
             @instance.generate(@key).should equal(@request)
         end
 
         it "should set its content to the generated request" do
             @instance.generate(@key)
             @instance.content.should equal(@request)
         end
     end
 
     describe "when a CSR is saved" do
         it "should allow arguments" do
             csr = Puppet::SSL::CertificateRequest.new("me")
             csr.class.indirection.stubs(:save)
 
             lambda { csr.save :ipaddress => "foo" }.should_not raise_error
         end
 
         describe "and a CA is available" do
             it "should save the CSR and trigger autosigning" do
                 ca = mock 'ca', :autosign
                 Puppet::SSL::CertificateAuthority.expects(:instance).returns ca
 
                 csr = Puppet::SSL::CertificateRequest.new("me")
                 Puppet::SSL::CertificateRequest.indirection.expects(:save).with(csr)
 
                 csr.save
             end
         end
 
         describe "and a CA is not available" do
             it "should save the CSR" do
                 Puppet::SSL::CertificateAuthority.expects(:instance).returns nil
 
                 csr = Puppet::SSL::CertificateRequest.new("me")
                 Puppet::SSL::CertificateRequest.indirection.expects(:save).with(csr)
 
                 csr.save
             end
         end
     end
 end
diff --git a/spec/unit/ssl/key.rb b/spec/unit/ssl/key.rb
index b23470451..cfeaf7906 100755
--- a/spec/unit/ssl/key.rb
+++ b/spec/unit/ssl/key.rb
@@ -1,198 +1,198 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/ssl/key'
 
 describe Puppet::SSL::Key do
     before do
         @class = Puppet::SSL::Key
     end
 
     it "should be extended with the Indirector module" do
-        @class.metaclass.should be_include(Puppet::Indirector)
+        @class.singleton_class.should be_include(Puppet::Indirector)
     end
 
     it "should indirect key" do
         @class.indirection.name.should == :key
     end
 
     it "should default to the :file terminus" do
         @class.indirection.terminus_class.should == :file
     end
 
     it "should only support the text format" do
         @class.supported_formats.should == [:s]
     end
 
     it "should have a method for determining whether it's a CA key" do
         @class.new("test").should respond_to(:ca?)
     end
 
     it "should consider itself a ca key if its name matches the CA_NAME" do
         @class.new(Puppet::SSL::Host.ca_name).should be_ca
     end
 
     describe "when initializing" do
         it "should set its password file to the :capass if it's a CA key" do
             Puppet.settings.stubs(:value).returns "whatever"
             Puppet.settings.stubs(:value).with(:capass).returns "/ca/pass"
 
             key = Puppet::SSL::Key.new(Puppet::SSL::Host.ca_name)
             key.password_file.should == "/ca/pass"
         end
 
         it "should downcase its name" do
             @class.new("MyName").name.should == "myname"
         end
 
         it "should set its password file to the default password file if it is not the CA key" do
             Puppet.settings.stubs(:value).returns "whatever"
             Puppet.settings.stubs(:value).with(:passfile).returns "/normal/pass"
 
             key = Puppet::SSL::Key.new("notca")
             key.password_file.should == "/normal/pass"
         end
     end
 
     describe "when managing instances" do
         before do
             @key = @class.new("myname")
         end
 
         it "should have a name attribute" do
             @key.name.should == "myname"
         end
 
         it "should have a content attribute" do
             @key.should respond_to(:content)
         end
 
         it "should be able to read keys from disk" do
             path = "/my/path"
             File.expects(:read).with(path).returns("my key")
             key = mock 'key'
             OpenSSL::PKey::RSA.expects(:new).returns(key)
             @key.read(path).should equal(key)
             @key.content.should equal(key)
         end
 
         it "should not try to use the provided password file if the file does not exist" do
             FileTest.stubs(:exist?).returns false
             @key.password_file = "/path/to/password"
 
             path = "/my/path"
 
             File.stubs(:read).with(path).returns("my key")
             OpenSSL::PKey::RSA.expects(:new).with("my key", nil).returns(mock('key'))
             File.expects(:read).with("/path/to/password").never
 
             @key.read(path)
         end
 
         it "should read the key with the password retrieved from the password file if one is provided" do
             FileTest.stubs(:exist?).returns true
             @key.password_file = "/path/to/password"
 
             path = "/my/path"
             File.expects(:read).with(path).returns("my key")
             File.expects(:read).with("/path/to/password").returns("my password")
 
             key = mock 'key'
             OpenSSL::PKey::RSA.expects(:new).with("my key", "my password").returns(key)
             @key.read(path).should equal(key)
             @key.content.should equal(key)
         end
 
         it "should return an empty string when converted to a string with no key" do
             @key.to_s.should == ""
         end
 
         it "should convert the key to pem format when converted to a string" do
             key = mock 'key', :to_pem => "pem"
             @key.content = key
             @key.to_s.should == "pem"
         end
 
         it "should have a :to_text method that it delegates to the actual key" do
             real_key = mock 'key'
             real_key.expects(:to_text).returns "keytext"
             @key.content = real_key
             @key.to_text.should == "keytext"
         end
     end
 
     describe "when generating the private key" do
         before do
             @instance = @class.new("test")
 
             @key = mock 'key'
         end
 
         it "should create an instance of OpenSSL::PKey::RSA" do
             OpenSSL::PKey::RSA.expects(:new).returns(@key)
 
             @instance.generate
         end
 
         it "should create the private key with the keylength specified in the settings" do
             Puppet.settings.expects(:value).with(:keylength).returns("50")
             OpenSSL::PKey::RSA.expects(:new).with(50).returns(@key)
 
             @instance.generate
         end
 
         it "should set the content to the generated key" do
             OpenSSL::PKey::RSA.stubs(:new).returns(@key)
             @instance.generate
             @instance.content.should equal(@key)
         end
 
         it "should return the generated key" do
             OpenSSL::PKey::RSA.stubs(:new).returns(@key)
             @instance.generate.should equal(@key)
         end
 
         it "should return the key in pem format" do
             @instance.generate
             @instance.content.expects(:to_pem).returns "my normal key"
             @instance.to_s.should == "my normal key"
         end
 
         describe "with a password file set" do
             it "should return a nil password if the password file does not exist" do
                 FileTest.expects(:exist?).with("/path/to/pass").returns false
                 File.expects(:read).with("/path/to/pass").never
 
                 @instance.password_file = "/path/to/pass"
 
                 @instance.password.should be_nil
             end
 
             it "should return the contents of the password file as its password" do
                 FileTest.expects(:exist?).with("/path/to/pass").returns true
                 File.expects(:read).with("/path/to/pass").returns "my password"
 
                 @instance.password_file = "/path/to/pass"
 
                 @instance.password.should == "my password"
             end
 
             it "should export the private key to text using the password" do
                 Puppet.settings.stubs(:value).with(:keylength).returns("50")
 
                 @instance.password_file = "/path/to/pass"
                 @instance.stubs(:password).returns "my password"
 
                 OpenSSL::PKey::RSA.expects(:new).returns(@key)
                 @instance.generate
 
                 cipher = mock 'cipher'
                 OpenSSL::Cipher::DES.expects(:new).with(:EDE3, :CBC).returns cipher
                 @key.expects(:export).with(cipher, "my password").returns "my encrypted key"
 
                 @instance.to_s.should == "my encrypted key"
             end
         end
     end
 end
diff --git a/spec/unit/util/cacher.rb b/spec/unit/util/cacher.rb
index 40688bc88..eb8515e4d 100755
--- a/spec/unit/util/cacher.rb
+++ b/spec/unit/util/cacher.rb
@@ -1,185 +1,185 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/util/cacher'
 
 class ExpirerTest
     include Puppet::Util::Cacher::Expirer
 end
 
 class CacheTest
     @@init_count = 0
 
     include Puppet::Util::Cacher
     cached_attr(:instance_cache) { Time.now }
 end
 
 describe Puppet::Util::Cacher::Expirer do
     before do
         @expirer = ExpirerTest.new
     end
 
     it "should be able to test whether a timestamp is expired" do
         @expirer.should respond_to(:dependent_data_expired?)
     end
 
     it "should be able to expire all values" do
         @expirer.should respond_to(:expire)
     end
 
     it "should consider any value to be valid if it has never been expired" do
         @expirer.should_not be_dependent_data_expired(Time.now)
     end
 
     it "should consider any value created after expiration to be expired" do
         @expirer.expire
         @expirer.should be_dependent_data_expired(Time.now - 1)
     end
 end
 
 describe Puppet::Util::Cacher do
     it "should be extended with the Expirer module" do
-        Puppet::Util::Cacher.metaclass.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
+        Puppet::Util::Cacher.singleton_class.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
     end
 
     it "should support defining cached attributes" do
         CacheTest.methods.should be_include("cached_attr")
     end
 
     it "should default to the Cacher module as its expirer" do
         CacheTest.new.expirer.should equal(Puppet::Util::Cacher)
     end
 
     describe "when using cached attributes" do
         before do
             @expirer = ExpirerTest.new
             @object = CacheTest.new
 
             @object.stubs(:expirer).returns @expirer
         end
 
         it "should create a getter for the cached attribute" do
             @object.should respond_to(:instance_cache)
         end
 
         it "should return a value calculated from the provided block" do
             time = Time.now
             Time.stubs(:now).returns time
             @object.instance_cache.should equal(time)
         end
 
         it "should return the cached value from the getter every time if the value is not expired" do
             @object.instance_cache.should equal(@object.instance_cache)
         end
 
         it "should regenerate and return a new value using the provided block if the value has been expired" do
             value = @object.instance_cache
             @expirer.expire
             @object.instance_cache.should_not equal(value)
         end
 
         it "should be able to trigger expiration on its expirer" do
             @expirer.expects(:expire)
             @object.expire
         end
 
         it "should do nothing when asked to expire when no expirer is available" do
             cacher = CacheTest.new
             class << cacher
                 def expirer
                     nil
                 end
             end
             lambda { cacher.expire }.should_not raise_error
         end
 
         it "should be able to cache false values" do
             @object.expects(:init_instance_cache).returns false
             @object.instance_cache.should be_false
             @object.instance_cache.should be_false
         end
 
         it "should cache values again after expiration" do
             @object.instance_cache
             @expirer.expire
             @object.instance_cache.should equal(@object.instance_cache)
         end
 
         it "should always consider a value expired if it has no expirer" do
             @object.stubs(:expirer).returns nil
             @object.instance_cache.should_not equal(@object.instance_cache)
         end
 
         it "should allow writing of the attribute" do
             @object.should respond_to(:instance_cache=)
         end
 
         it "should correctly configure timestamps for expiration when the cached attribute is written to" do
             @object.instance_cache = "foo"
             @expirer.expire
             @object.instance_cache.should_not == "foo"
         end
 
         it "should allow specification of a ttl for cached attributes" do
             klass = Class.new do
                 include Puppet::Util::Cacher
             end
 
             klass.cached_attr(:myattr, :ttl => 5)  { Time.now }
 
             klass.attr_ttl(:myattr).should == 5
         end
 
         it "should allow specification of a ttl as a string" do
             klass = Class.new do
                 include Puppet::Util::Cacher
             end
 
             klass.cached_attr(:myattr, :ttl => "5")  { Time.now }
 
             klass.attr_ttl(:myattr).should == 5
         end
 
         it "should fail helpfully if the ttl cannot be converted to an integer" do
             klass = Class.new do
                 include Puppet::Util::Cacher
             end
 
             lambda { klass.cached_attr(:myattr, :ttl => "yep")  { Time.now } }.should raise_error(ArgumentError)
         end
 
         it "should not check for a ttl expiration if the class does not support that method" do
             klass = Class.new do
                 extend Puppet::Util::Cacher
             end
 
-            klass.metaclass.cached_attr(:myattr) { "eh" }
+            klass.singleton_class.cached_attr(:myattr) { "eh" }
             klass.myattr
         end
 
         it "should automatically expire cached attributes whose ttl has expired, even if no expirer is present" do
             klass = Class.new do
                 def self.to_s
                     "CacheTestClass"
                 end
                 include Puppet::Util::Cacher
                 attr_accessor :value
             end
 
             klass.cached_attr(:myattr, :ttl => 5)  { self.value += 1; self.value }
 
             now = Time.now
             later = Time.now + 15
 
             instance = klass.new
             instance.value = 0
             instance.myattr.should == 1
 
             Time.expects(:now).returns later
 
             # This call should get the new Time value, which should expire the old value
             instance.myattr.should == 2
         end
     end
 end
diff --git a/spec/unit/util/tagging.rb b/spec/unit/util/tagging.rb
index 3486f46f2..04800b378 100755
--- a/spec/unit/util/tagging.rb
+++ b/spec/unit/util/tagging.rb
@@ -1,102 +1,102 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2008-01-19.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/util/tagging'
 
 describe Puppet::Util::Tagging, "when adding tags" do
     before do
         @tagger = Object.new
         @tagger.extend(Puppet::Util::Tagging)
     end
 
     it "should have a method for adding tags" do
         @tagger.should be_respond_to(:tag)
     end
 
     it "should have a method for returning all tags" do
         @tagger.should be_respond_to(:tags)
     end
 
     it "should add tags to the returned tag list" do
         @tagger.tag("one")
         @tagger.tags.should be_include("one")
     end
 
     it "should not add duplicate tags to the returned tag list" do
         @tagger.tag("one")
         @tagger.tag("one")
         @tagger.tags.should == ["one"]
     end
 
     it "should return a duplicate of the tag list, rather than the original" do
         @tagger.tag("one")
         tags = @tagger.tags
         tags << "two"
         @tagger.tags.should_not be_include("two")
     end
 
     it "should add all provided tags to the tag list" do
         @tagger.tag("one", "two")
         @tagger.tags.should be_include("one")
         @tagger.tags.should be_include("two")
     end
 
     it "should fail on tags containing '*' characters" do
         lambda { @tagger.tag("bad*tag") }.should raise_error(Puppet::ParseError)
     end
 
     it "should fail on tags starting with '-' characters" do
         lambda { @tagger.tag("-badtag") }.should raise_error(Puppet::ParseError)
     end
 
     it "should fail on tags containing ' ' characters" do
         lambda { @tagger.tag("bad tag") }.should raise_error(Puppet::ParseError)
     end
 
     it "should allow alpha tags" do
         lambda { @tagger.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
     end
 
     it "should allow tags containing '.' characters" do
         lambda { @tagger.tag("good.tag") }.should_not raise_error(Puppet::ParseError)
     end
 
     it "should provide a method for testing tag validity" do
-        @tagger.metaclass.publicize_methods(:valid_tag?)  { @tagger.should be_respond_to(:valid_tag?) }
+        @tagger.singleton_class.publicize_methods(:valid_tag?)  { @tagger.should be_respond_to(:valid_tag?) }
     end
 
     it "should add qualified classes as tags" do
         @tagger.tag("one::two")
         @tagger.tags.should be_include("one::two")
     end
 
     it "should add each part of qualified classes as tags" do
         @tagger.tag("one::two::three")
         @tagger.tags.should be_include("one")
         @tagger.tags.should be_include("two")
         @tagger.tags.should be_include("three")
     end
 
     it "should indicate when the object is tagged with a provided tag" do
         @tagger.tag("one")
         @tagger.should be_tagged("one")
     end
 
     it "should indicate when the object is not tagged with a provided tag" do
         @tagger.should_not be_tagged("one")
     end
 
     it "should indicate when the object is tagged with any tag in an array" do
         @tagger.tag("one")
         @tagger.should be_tagged("one","two","three")
     end
 
     it "should indicate when the object is not tagged with any tag in an array" do
         @tagger.tag("one")
         @tagger.should_not be_tagged("two","three")
     end
 end
diff --git a/test/language/scope.rb b/test/language/scope.rb
index 8b06e0d64..d7f37ebb6 100755
--- a/test/language/scope.rb
+++ b/test/language/scope.rb
@@ -1,481 +1,481 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'mocha'
 require 'puppettest'
 require 'puppettest/parsertesting'
 require 'puppettest/resourcetesting'
 
 # so, what kind of things do we want to test?
 
 # we don't need to test function, since we're confident in the
 # library tests.  We do, however, need to test how things are actually
 # working in the language.
 
 # so really, we want to do things like test that our ast is correct
 # and test whether we've got things in the right scopes
 
 class TestScope < Test::Unit::TestCase
     include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
 
     def to_ary(hash)
         hash.collect { |key,value|
             [key,value]
         }
     end
 
     def test_variables
         config = mkcompiler
         topscope = config.topscope
         midscope = config.newscope(topscope)
         botscope = config.newscope(midscope)
 
         scopes = {:top => topscope, :mid => midscope, :bot => botscope}
 
         # Set a variable in the top and make sure all three can get it
         topscope.setvar("first", "topval")
         scopes.each do |name, scope|
             assert_equal("topval", scope.lookupvar("first", false), "Could not find var in %s" % name)
         end
 
         # Now set a var in the midscope and make sure the mid and bottom can see it but not the top
         midscope.setvar("second", "midval")
         assert_equal(:undefined, scopes[:top].lookupvar("second", false), "Found child var in top scope")
         [:mid, :bot].each do |name|
             assert_equal("midval", scopes[name].lookupvar("second", false), "Could not find var in %s" % name)
         end
 
         # And set something in the bottom, and make sure we only find it there.
         botscope.setvar("third", "botval")
         [:top, :mid].each do |name|
             assert_equal(:undefined, scopes[name].lookupvar("third", false), "Found child var in top scope")
         end
         assert_equal("botval", scopes[:bot].lookupvar("third", false), "Could not find var in bottom scope")
 
 
         # Test that the scopes convert to hash structures correctly.
         # For topscope recursive vs non-recursive should be identical
         assert_equal(topscope.to_hash(false), topscope.to_hash(true),
                      "Recursive and non-recursive hash is identical for topscope")
 
         # Check the variable we expect is present.
         assert_equal({"first" => "topval"}, topscope.to_hash(),
                      "topscope returns the expected hash of variables")
 
         # Now, check that midscope does the right thing in all cases.
         assert_equal({"second" => "midval"},
                      midscope.to_hash(false),
                      "midscope non-recursive hash contains only midscope variable")
         assert_equal({"first" => "topval", "second" => "midval"},
                      midscope.to_hash(true),
                      "midscope recursive hash contains topscope variable also")
 
         # Finally, check the ability to shadow symbols by adding a shadow to
         # bottomscope, then checking that we see the right stuff.
         botscope.setvar("first", "shadowval")
         assert_equal({"third" => "botval", "first" => "shadowval"},
                      botscope.to_hash(false),
                      "botscope has the right non-recursive hash")
         assert_equal({"third" => "botval", "first" => "shadowval", "second" => "midval"},
                      botscope.to_hash(true),
                      "botscope values shadow parent scope values")
     end
 
     def test_declarative
         # set to declarative
         top = mkscope
         sub = mkscope(:parent => top)
 
         assert_nothing_raised {
             top.setvar("test","value")
         }
         assert_raise(Puppet::ParseError) {
             top.setvar("test","other")
         }
         assert_nothing_raised {
             sub.setvar("test","later")
         }
         assert_raise(Puppet::ParseError) {
             top.setvar("test","yeehaw")
         }
     end
 
     def test_setdefaults
         config = mkcompiler
 
         scope = config.topscope
 
         defaults = scope.instance_variable_get("@defaults")
 
         # First the case where there are no defaults and we pass a single param
         param = stub :name => "myparam", :file => "f", :line => "l"
         scope.setdefaults(:mytype, param)
         assert_equal({"myparam" => param}, defaults[:mytype], "Did not set default correctly")
 
         # Now the case where we pass in multiple parameters
         param1 = stub :name => "one", :file => "f", :line => "l"
         param2 = stub :name => "two", :file => "f", :line => "l"
         scope.setdefaults(:newtype, [param1, param2])
         assert_equal({"one" => param1, "two" => param2}, defaults[:newtype], "Did not set multiple defaults correctly")
 
         # And the case where there's actually a conflict.  Use the first default for this.
         newparam = stub :name => "myparam", :file => "f", :line => "l"
         assert_raise(Puppet::ParseError, "Allowed resetting of defaults") do
             scope.setdefaults(:mytype, param)
         end
         assert_equal({"myparam" => param}, defaults[:mytype], "Replaced default even though there was a failure")
     end
 
     def test_lookupdefaults
         config = mkcompiler
         top = config.topscope
 
         # Make a subscope
         sub = config.newscope(top)
 
         topdefs = top.instance_variable_get("@defaults")
         subdefs = sub.instance_variable_get("@defaults")
 
         # First add some defaults to our top scope
         topdefs[:t1] = {:p1 => :p2, :p3 => :p4}
         topdefs[:t2] = {:p5 => :p6}
 
         # Then the sub scope
         subdefs[:t1] = {:p1 => :p7, :p8 => :p9}
         subdefs[:t2] = {:p5 => :p10, :p11 => :p12}
 
         # Now make sure we get the correct list back
         result = nil
         assert_nothing_raised("Could not get defaults") do
             result = sub.lookupdefaults(:t1)
         end
         assert_equal(:p9, result[:p8], "Did not get child defaults")
         assert_equal(:p4, result[:p3], "Did not override parent defaults with child default")
         assert_equal(:p7, result[:p1], "Did not get parent defaults")
     end
 
     def test_parent
         config = mkcompiler
         top = config.topscope
 
         # Make a subscope
         sub = config.newscope(top)
 
         assert_equal(top, sub.parent, "Did not find parent scope correctly")
         assert_equal(top, sub.parent, "Did not find parent scope on second call")
     end
 
     def test_strinterp
         # Make and evaluate our classes so the qualified lookups work
         parser = mkparser
         klass = parser.newclass("")
         scope = mkscope(:parser => parser)
         Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => scope, :source => mock('source')).evaluate
 
         assert_nothing_raised {
             scope.setvar("test","value")
         }
 
         scopes = {"" => scope}
 
         %w{one one::two one::two::three}.each do |name|
             klass = parser.newclass(name)
             Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => scope, :source => mock('source')).evaluate
             scopes[name] = scope.compiler.class_scope(klass)
             scopes[name].setvar("test", "value-%s" % name.sub(/.+::/,''))
         end
 
         assert_equal("value", scope.lookupvar("::test"), "did not look up qualified value correctly")
         tests = {
             "string ${test}" => "string value",
             "string ${one::two::three::test}" => "string value-three",
             "string $one::two::three::test" => "string value-three",
             "string ${one::two::test}" => "string value-two",
             "string $one::two::test" => "string value-two",
             "string ${one::test}" => "string value-one",
             "string $one::test" => "string value-one",
             "string ${::test}" => "string value",
             "string $::test" => "string value",
             "string ${test} ${test} ${test}" => "string value value value",
             "string $test ${test} $test" => "string value value value",
             "string \\$test" => "string $test",
             '\\$test string' => "$test string",
             '$test string' => "value string",
             'a testing $' => "a testing $",
             'a testing \$' => "a testing $",
             "an escaped \\\n carriage return" => "an escaped  carriage return",
             '\$' => "$",
             '\s' => "\s",
             '\t' => "\t",
             '\n' => "\n"
         }
 
         tests.each do |input, output|
             assert_nothing_raised("Failed to scan %s" % input.inspect) do
                 assert_equal(output, scope.strinterp(input),
                     'did not parserret %s correctly' % input.inspect)
             end
         end
 
         logs = []
         Puppet::Util::Log.close
         Puppet::Util::Log.newdestination(logs)
 
         # #523
         %w{d f h l w z}.each do |l|
             string = "\\" + l
             assert_nothing_raised do
                 assert_equal(string, scope.strinterp(string),
                     'did not parserret %s correctly' % string)
             end
 
             assert(logs.detect { |m| m.message =~ /Unrecognised escape/ },
                 "Did not get warning about escape sequence with %s" % string)
             logs.clear
         end
     end
 
     def test_tagfunction
         Puppet::Parser::Functions.function(:tag)
         scope = mkscope
         resource = mock 'resource'
         scope.resource = resource
         resource.expects(:tag).with("yayness", "booness")
 
         scope.function_tag(%w{yayness booness})
     end
 
     def test_includefunction
         parser = mkparser
         scope = mkscope :parser => parser
 
         myclass = parser.newclass "myclass"
         otherclass = parser.newclass "otherclass"
 
         function = Puppet::Parser::AST::Function.new(
             :name => "include",
             :ftype => :statement,
             :arguments => AST::ASTArray.new(
                 :children => [nameobj("myclass"), nameobj("otherclass")]
             )
         )
 
         assert_nothing_raised do
             function.evaluate scope
         end
 
         scope.compiler.send(:evaluate_generators)
 
         [myclass, otherclass].each do |klass|
             assert(scope.compiler.class_scope(klass),
                 "%s was not set" % klass.classname)
         end
     end
 
     def test_definedfunction
         Puppet::Parser::Functions.function(:defined)
         parser = mkparser
         %w{one two}.each do |name|
             parser.newdefine name
         end
 
         scope = mkscope :parser => parser
 
         assert_nothing_raised {
             %w{one two file user}.each do |type|
                 assert(scope.function_defined([type]),
                     "Class #{type} was not considered defined")
             end
 
             assert(!scope.function_defined(["nopeness"]),
                 "Class 'nopeness' was incorrectly considered defined")
         }
     end
 
     # Make sure we know what we consider to be truth.
     def test_truth
         assert_equal(true, Puppet::Parser::Scope.true?("a string"),
             "Strings not considered true")
         assert_equal(true, Puppet::Parser::Scope.true?(true),
             "True considered true")
         assert_equal(false, Puppet::Parser::Scope.true?(""),
             "Empty strings considered true")
         assert_equal(false, Puppet::Parser::Scope.true?(false),
             "false considered true")
         assert_equal(false, Puppet::Parser::Scope.true?(:undef),
             "undef considered true")
     end
 
     # Verify that we recursively mark as exported the results of collectable
     # components.
     def test_virtual_definitions_do_not_get_evaluated
         config = mkcompiler
         parser = config.parser
 
         # Create a default source
         config.topscope.source = parser.newclass "", ""
 
         # And a scope resource
         scope_res = stub 'scope_resource', :virtual? => true, :exported? => false, :tags => [], :builtin? => true, :type => "eh", :title => "bee"
         config.topscope.resource = scope_res
 
         args = AST::ASTArray.new(
             :file => tempfile(),
             :line => rand(100),
             :children => [nameobj("arg")]
         )
 
         # Create a top-level define
         parser.newdefine "one", :arguments => [%w{arg}],
             :code => AST::ASTArray.new(
                 :children => [
                     resourcedef("file", "/tmp", {"owner" => varref("arg")})
                 ]
             )
 
         # create a resource that calls our third define
         obj = resourcedef("one", "boo", {"arg" => "parentfoo"})
 
         # And mark it as virtual
         obj.virtual = true
 
         # And then evaluate it
         obj.evaluate config.topscope
 
         # And run the loop.
         config.send(:evaluate_generators)
 
         %w{File}.each do |type|
             objects = config.resources.find_all { |r| r.type == type and r.virtual }
 
             assert(objects.empty?, "Virtual define got evaluated")
         end
     end
 
     if defined? ::ActiveRecord
     # Verify that we can both store and collect an object in the same
     # run, whether it's in the same scope as a collection or a different
     # scope.
     def test_storeandcollect
         catalog_cache_class = Puppet::Resource::Catalog.indirection.cache_class
         facts_cache_class = Puppet::Node::Facts.indirection.cache_class
         node_cache_class = Puppet::Node.indirection.cache_class
         Puppet[:storeconfigs] = true
         Puppet::Rails.init
         sleep 1
         children = []
         Puppet[:code] = "
 class yay {
     @@host { myhost: ip => \"192.168.0.2\" }
 }
 include yay
 @@host { puppet: ip => \"192.168.0.3\" }
 Host <<||>>"
 
         interp = nil
         assert_nothing_raised {
             interp = Puppet::Parser::Interpreter.new
         }
 
         config = nil
         # We run it twice because we want to make sure there's no conflict
         # if we pull it up from the database.
         node = mknode
         node.parameters = {"hostname" => node.name}
         2.times { |i|
             assert_nothing_raised {
                 config = interp.compile(node)
             }
 
             flat = config.extract.flatten
 
             %w{puppet myhost}.each do |name|
                 assert(flat.find{|o| o.name == name }, "Did not find #{name}")
             end
         }
         Puppet[:storeconfigs] = false
         Puppet::Resource::Catalog.cache_class =  catalog_cache_class
         Puppet::Node::Facts.cache_class = facts_cache_class
         Puppet::Node.cache_class = node_cache_class
     end
     else
         $stderr.puts "No ActiveRecord -- skipping collection tests"
     end
 
     def test_namespaces
         scope = mkscope
 
         assert_equal([""], scope.namespaces,
             "Started out with incorrect namespaces")
         assert_nothing_raised { scope.add_namespace("fun::test") }
         assert_equal(["fun::test"], scope.namespaces,
             "Did not add namespace correctly")
         assert_nothing_raised { scope.add_namespace("yay::test") }
         assert_equal(["fun::test", "yay::test"], scope.namespaces,
             "Did not add extra namespace correctly")
     end
 
     def test_find_hostclass_and_find_definition
         parser = mkparser
 
         # Make sure our scope calls the parser find_hostclass method with
         # the right namespaces
         scope = mkscope :parser => parser
 
-        parser.metaclass.send(:attr_accessor, :last)
+        parser.singleton_class.send(:attr_accessor, :last)
 
         methods = [:find_hostclass, :find_definition]
         methods.each do |m|
             parser.meta_def(m) do |namespace, name|
                 @checked ||= []
                 @checked << [namespace, name]
 
                 # Only return a value on the last call.
                 if @last == namespace
                     ret = @checked.dup
                     @checked.clear
                     return ret
                 else
                     return nil
                 end
             end
         end
 
         test = proc do |should|
             parser.last = scope.namespaces[-1]
             methods.each do |method|
                 result = scope.send(method, "testing")
                 assert_equal(should, result,
                     "did not get correct value from %s with namespaces %s" %
                     [method, scope.namespaces.inspect])
             end
         end
 
         # Start with the empty namespace
         assert_nothing_raised { test.call([["", "testing"]]) }
 
         # Now add a namespace
         scope.add_namespace("a")
         assert_nothing_raised { test.call([["a", "testing"]]) }
 
         # And another
         scope.add_namespace("b")
         assert_nothing_raised { test.call([["a", "testing"], ["b", "testing"]]) }
     end
 
     # #629 - undef should be "" or :undef
     def test_lookupvar_with_undef
         scope = mkscope
 
         scope.setvar("testing", :undef)
 
         assert_equal(:undef, scope.lookupvar("testing", false),
             "undef was not returned as :undef when not string")
 
         assert_equal("", scope.lookupvar("testing", true),
             "undef was not returned as '' when string")
     end
 end
 
diff --git a/test/network/server/mongrel_test.rb b/test/network/server/mongrel_test.rb
index 54bfb3978..4414097ab 100755
--- a/test/network/server/mongrel_test.rb
+++ b/test/network/server/mongrel_test.rb
@@ -1,105 +1,105 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'mocha'
 
 class TestMongrelServer < PuppetTest::TestCase
     confine "Missing mongrel" => Puppet.features.mongrel?
 
     include PuppetTest::ServerTest
 
     def mkserver(handlers = nil)
         handlers ||= { :Status => nil }
         mongrel = Puppet::Network::HTTPServer::Mongrel.new(handlers)
     end
 
     # Make sure client info is correctly extracted.
     def test_client_info
         obj = Object.new
-        obj.metaclass.send(:attr_accessor, :params)
+        obj.singleton_class.send(:attr_accessor, :params)
         params = {}
         obj.params = params
 
         mongrel = mkserver
 
         ip = Facter.value(:ipaddress)
         params["REMOTE_ADDR"] = ip
         params[Puppet[:ssl_client_header]] = ""
         params[Puppet[:ssl_client_verify_header]] = "failure"
         info = nil
         Resolv.expects(:getname).with(ip).returns("host.domain.com").times(4)
         assert_nothing_raised("Could not call client_info") do
             info = mongrel.send(:client_info, obj)
         end
         assert(! info.authenticated?, "Client info object was marked valid even though headers were missing")
         assert_equal(ip, info.ip, "Did not copy over ip correctly")
 
         assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
 
         # Now pass the X-Forwarded-For header and check it is preferred over REMOTE_ADDR
         params["REMOTE_ADDR"] = '127.0.0.1'
         params["HTTP_X_FORWARDED_FOR"] = ip
         info = nil
         assert_nothing_raised("Could not call client_info") do
             info = mongrel.send(:client_info, obj)
         end
         assert(! info.authenticated?, "Client info object was marked valid even though headers were missing")
         assert_equal(ip, info.ip, "Did not copy over ip correctly")
 
         assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
 
         # Now add a valid auth header.
         params["REMOTE_ADDR"] = ip
         params["HTTP_X_FORWARDED_FOR"] = nil
         params[Puppet[:ssl_client_header]] = "/CN=host.domain.com"
         assert_nothing_raised("Could not call client_info") do
             info = mongrel.send(:client_info, obj)
         end
         assert(! info.authenticated?, "Client info object was marked valid even though the verify header was fals")
         assert_equal(ip, info.ip, "Did not copy over ip correctly")
         assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
 
         # Now change the verify header to be true
         params[Puppet[:ssl_client_verify_header]] = "SUCCESS"
         assert_nothing_raised("Could not call client_info") do
             info = mongrel.send(:client_info, obj)
         end
 
         assert(info.authenticated?, "Client info object was not marked valid even though all headers were correct")
         assert_equal(ip, info.ip, "Did not copy over ip correctly")
         assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
 
         # Now try it with a different header name
         params.delete(Puppet[:ssl_client_header])
         Puppet[:ssl_client_header] = "header_testing"
         params["header_testing"] = "/CN=other.domain.com"
         info = nil
         assert_nothing_raised("Could not call client_info with other header") do
             info = mongrel.send(:client_info, obj)
         end
 
         assert(info.authenticated?, "Client info object was not marked valid even though the header was present")
         assert_equal(ip, info.ip, "Did not copy over ip correctly")
         assert_equal("other.domain.com", info.name, "Did not copy over hostname correctly")
 
         # Now make sure it's considered invalid without that header
         params.delete("header_testing")
         info = nil
         assert_nothing_raised("Could not call client_info with no header") do
             info = mongrel.send(:client_info, obj)
         end
 
         assert(! info.authenticated?, "Client info object was marked valid without header")
         assert_equal(ip, info.ip, "Did not copy over ip correctly")
         assert_equal(Resolv.getname(ip), info.name, "Did not look up hostname correctly")
     end
 
     def test_daemonize
         mongrel = mkserver
 
         assert(mongrel.respond_to?(:daemonize), "Mongrel server does not respond to daemonize")
     end
 end