diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb
index e8a1a44a1..8ad66670a 100644
--- a/lib/puppet/parameter.rb
+++ b/lib/puppet/parameter.rb
@@ -1,578 +1,580 @@
 require 'puppet/util/methodhelper'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
 
 # The Parameter class is the implementation of a resource's attributes of _parameter_ kind.
 # The Parameter class is also the base class for {Puppet::Property}, and is used to describe meta-parameters
 # (parameters that apply to all resource types).
 # A Parameter (in contrast to a Property) has a single value where a property has both a current and a wanted value.
 # The Parameter class methods are used to configure and create an instance of Parameter that represents
 # one particular attribute data type; its valid value(s), and conversion to/from internal form.
 #
 # The intention is that a new parameter is created by using the DSL method {Puppet::Type.newparam}, or
 # {Puppet::Type.newmetaparam} if the parameter should be applicable to all resource types.
 #
 # A Parameter that does not specify and valid values (via {newvalues}) accepts any value.
 #
 # @see Puppet::Type
 # @see Puppet::Property
 # @api public
 #
 class Puppet::Parameter
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Util::MethodHelper
 
   require 'puppet/parameter/value_collection'
 
   class << self
     include Puppet::Util
     include Puppet::Util::Docs
     # Unused?
     # @todo The term "validater" only appears in this location in the Puppet code base. There is `validate`
     #   which seems to works fine without this attribute declaration.
     # @api private
     #
     attr_reader :validater
 
     # Unused?
     # @todo The term "munger" only appears in this location in the Puppet code base. There is munge and unmunge
     #  and they seem to work perfectly fine without this attribute declaration.
     # @api private
     #
     attr_reader :munger
 
     # @return [Symbol] The parameter name as given when it was created.
     attr_reader :name
 
     # @return [Object] The default value of the parameter as determined by the {defaultto} method, or nil if no
     #  default has been set.
     attr_reader :default
 
     # @comment This somewhat odd documentation construct is because the getter and setter are not
     #  orthogonal; the setter uses varargs and this confuses yard. To overcome the problem both the
     #  getter and the setter are documented here. If this issues is fixed, a todo will be displayed
     #  for the setter method, and the setter documentation can be moved there.
     #  Since the attribute is actually RW it should  perhaps instead just be implemented as a setter
     #  and a getter method (and no attr_xxx declaration).
     #
     # @!attribute [rw] required_features
     # @return [Array<Symbol>] The names of the _provider features_ required for this parameter to work.
     #   the returned names are always all lower case symbols.
     # @overload required_features
     #   Returns the required _provider features_ as an array of lower case symbols
     # @overload required_features=(*args)
     #   @param *args [Symbol] one or more names of required provider features
     #   Sets the required_provider_features_ from one or more values, or array. The given arguments
     #   are flattened, and internalized.
     # @api public
     # @dsl type
     #
     attr_reader :required_features
 
     # @return [Puppet::Parameter::ValueCollection] The set of valid values (or an empty set that accepts any value).
     # @api private
     #
     attr_reader :value_collection
 
     # @return [Boolean] Flag indicating whether this parameter is a meta-parameter or not.
     attr_accessor :metaparam
 
     # Defines how the `default` value of a parameter is computed.
     # The computation of the parameter's default value is defined by providing a value or a block.
     # A default of `nil` can not be used.
     # @overload defaultto(value)
     #   Defines the default value with a literal value
     #   @param value [Object] the literal value to use as the default value
     # @overload defaultto({|| ... })
     #   Defines that the default value is produced by the given block. The given block
     #   should produce the default value.
     # @raise [Puppet::DevError] if value is nil, and no block is given.
     # @return [void]
     # @see Parameter.default
     # @dsl type
     # @api public
     #
     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
 
     # Produces a documentation string.
     # If an enumeration of _valid values_ has been defined, it is appended to the documentation
     # for this parameter specified with the {desc} method.
     # @return [String] Returns a documentation string.
     # @api public
     #
     def doc
       @doc ||= ""
 
       unless defined?(@addeddocvals)
         @doc += value_collection.doc
 
         if f = self.required_features
           @doc += "  Requires features #{f.flatten.collect { |f| f.to_s }.join(" ")}."
         end
         @addeddocvals = true
       end
 
       @doc
     end
 
     # Removes the `default` method if defined.
     # Has no effect if the default method is not defined.
     # This method is intended to be used in a DSL scenario where a parameter inherits from a parameter
     # with a default value that is not wanted in the derived parameter (otherwise, simply do not define
     # a default value method).
     #
     # @return [void]
     # @see desc
     # @api public
     # @dsl type
     #
     def nodefault
       undef_method :default if public_method_defined? :default
     end
 
     # Sets the documentation for this parameter.
     # @param str [String] The documentation string to set
     # @return [String] the given `str` parameter
     # @see doc
     # @dsl type
     # @api public
     #
     def desc(str)
       @doc = str
     end
 
     # Initializes the instance variables.
     # Clears the internal value collection (set of allowed values).
     # @return [void]
     # @api private
     #
     def initvars
       @value_collection = ValueCollection.new
     end
 
     # @overload munge {|| ... }
     # Defines an optional method used to convert the parameter value from DSL/string form to an internal form.
     # If a munge method is not defined, the DSL/string value is used as is.
     # @note This adds a method with the name `unsafe_munge` in the created parameter class. Later this method is
     #   called in a context where exceptions will be rescued and handled.
     # @dsl type
     # @api public
     #
     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
 
     # @overload unmunge {|| ... }
     # Defines an optional method used to convert the parameter value to DSL/string form from an internal form.
     # If an `unmunge` method is not defined, the internal form is used.
     # @see munge
     # @note This adds a method with the name `unmunge` in the created parameter class.
     # @dsl type
     # @api public
     #
     def unmunge(&block)
       define_method(:unmunge, &block)
     end
 
     # Sets a marker indicating that this parameter is the _namevar_ (unique identifier) of the type
     # where the parameter is contained.
     # This also makes the parameter a required value. The marker can not be unset once it has been set.
     # @return [void]
     # @dsl type
     # @api public
     #
     def isnamevar
       @isnamevar = true
       @required = true
     end
 
     # @return [Boolean] Returns whether this parameter is the _namevar_ or not.
     # @api public
     #
     def isnamevar?
       @isnamevar
     end
 
     # Sets a marker indicating that this parameter is required.
     # Once set, it is not possible to make a parameter optional.
     # @return [void]
     # @dsl type
     # @api public
     #
     def isrequired
       @required = true
     end
 
     # @comment This method is not picked up by yard as it has a different signature than
     #   expected for an attribute (varargs). Instead, this method is documented as an overload
     #   of the attribute required_features. (Not ideal, but better than nothing).
     # @todo If this text appears in documentation - see comment in source and makes corrections - it means
     #   that an issue in yardoc has been fixed.
     #
     def required_features=(*args)
       @required_features = args.flatten.collect { |a| a.to_s.downcase.intern }
     end
 
     # Returns whether this parameter is required or not.
     # A parameter is required if a call has been made to the DSL method {isrequired}.
     # @return [Boolean] Returns whether this parameter is required or not.
     # @api public
     #
     def required?
       @required
     end
 
     # @overload validate {|| ... }
     # Defines an optional method that is used to validate the parameter's DSL/string value.
     # Validation should raise appropriate exceptions, the return value of the given block is ignored.
     # The easiest way to raise an appropriate exception is to call the method {Puppet::Util::Errors.fail} with
     # the message as an argument.
     # To validate the munged value instead, just munge the value (`munge(value)`).
     #
     # @return [void]
     # @dsl type
     # @api public
     #
     def validate(&block)
       define_method(:unsafe_validate, &block)
     end
 
     # Defines valid values for the parameter (enumeration or regular expressions).
     # The set of valid values for the parameter can be limited to a (mix of) literal values and
     # regular expression patterns.
     # @note Each call to this method adds to the set of valid values
     # @param names [Symbol, Regexp] The set of valid literal values and/or patterns for the parameter.
     # @return [void]
     # @dsl type
     # @api public
     #
     def newvalues(*names)
       @value_collection.newvalues(*names)
     end
 
     # Makes the given `name` an alias for the given `other` name.
     # Or said differently, the valid value `other` can now also be referred to via the given `name`.
     # Aliasing may affect how the parameter's value is serialized/stored (it may store the `other` value
     # instead of the alias).
     # @api public
     # @dsl type
     #
     def aliasvalue(name, other)
       @value_collection.aliasvalue(name, other)
     end
   end
 
   # Creates instance (proxy) methods that delegates to a class method with the same name.
   # @api private
   #
   def self.proxymethods(*values)
     values.each { |val|
       define_method(val) do
         self.class.send(val)
       end
     }
   end
 
   # @!method required?
   #   (see required?)
   # @!method isnamevar?
   #   (see isnamevar?)
   #
   proxymethods("required?", "isnamevar?")
 
   # @return [Puppet::Resource] A reference to the resource this parameter is an attribute of (the _associated resource_).
   attr_accessor :resource
 
   # @comment LAK 2007-05-09: Keep the @parent around for backward compatibility.
   # @return [Puppet::Parameter] A reference to the parameter's parent kept for backwards compatibility.
   # @api private
   #
   attr_accessor :parent
 
   # Returns a string representation of the resource's containment path in
   # the catalog.
   # @return [String]
   def path
     @path ||= '/' + pathbuilder.join('/')
   end
 
   # @return [Integer] Returns the result of calling the same method on the associated resource.
   def line
     resource.line
   end
 
   # @return [Integer] Returns the result of calling the same method on the associated resource.
   def file
     resource.file
   end
 
   # @return [Integer] Returns the result of calling the same method on the associated resource.
   def version
     resource.version
   end
 
 
   # Initializes the parameter with a required resource reference and optional attribute settings.
   # The option `:resource` must be specified or an exception is raised. Any additional options passed
   # are used to initialize the attributes of this parameter by treating each key in the `options` hash as
   # the name of the attribute to set, and the value as the value to set.
   # @param options [Hash{Symbol => Object]] Options, where `resource` is required
   # @option options [Puppet::Resource] :resource The resource this parameter holds a value for. Required.
   # @raise [Puppet::DevError] If resource is not specified in the options hash.
   # @api public
   # @note A parameter should be created via the DSL method {Puppet::Type::newparam}
   #
   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 #{self.class.name}"
     end
 
     set_options(options)
   end
 
   # Writes the given `msg` to the log with the loglevel indicated by the associated resource's
   # `loglevel` parameter.
   # @todo is loglevel a metaparameter? it is looked up with `resource[:loglevel]`
   # @return [void]
   # @api public
   def log(msg)
     send_log(resource[:loglevel], msg)
   end
 
   # @return [Boolean] Returns whether this parameter is a meta-parameter or not.
   def metaparam?
     self.class.metaparam
   end
 
   # @!attribute [r] name
   # @return [Symbol] The parameter's name as given when it was created.
   # @note Since a Parameter defines the name at the class level, each Parameter class must be
   #  unique within a type's inheritance chain.
   # @comment 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
     self.class.name
   end
 
   # @return [Boolean] Returns true if this parameter, the associated resource, or overall puppet mode is `noop`.
   # @todo How is noop mode set for a parameter? Is this of value in DSL to inhibit a parameter?
   #
   def noop
     @noop ||= false
     tmp = @noop || self.resource.noop || Puppet[:noop] || false
     #debug "noop is #{tmp}"
     tmp
   end
 
   # Returns an array of strings representing the containment heirarchy
   # (types/classes) that make up the path to the resource from the root
   # of the catalog.  This is mostly used for logging purposes.
   #
   # @api private
   def pathbuilder
     if @resource
       return [@resource.pathbuilder, self.name]
     else
       return [self.name]
     end
   end
 
   # This is the default implementation of `munge` that simply produces the value (if it is valid).
   # The DSL method {munge} should be used to define an overriding method if munging is required.
   #
   # @api private
   #
   def unsafe_munge(value)
     self.class.value_collection.munge(value)
   end
 
   # Unmunges the value by transforming it from internal form to DSL form.
   # This is the default implementation of `unmunge` that simply returns the value without processing.
   # The DSL method {unmunge} should be used to define an overriding method if required.
   # @return [Object] the unmunged value
   #
   def unmunge(value)
     value
   end
 
   # Munges the value to internal form.
   # This implementation of `munge` provides exception handling around the specified munging of this parameter.
   # @note This method should not be overridden. Use the DSL method {munge} to define a munging method
   #   if required.
   # @param value [Object] the DSL value to munge
   # @return [Object] the munged (internal) value
   #
   def munge(value)
     begin
       ret = unsafe_munge(value)
     rescue Puppet::Error => detail
       Puppet.debug "Reraising #{detail}"
       raise
     rescue => detail
       raise Puppet::DevError, "Munging failed for value #{value.inspect} in class #{self.name}: #{detail}", detail.backtrace
     end
     ret
   end
 
   # This is the default implementation of `validate` that may be overridden by the DSL method {validate}.
   # If no valid values have been defined, the given value is accepted, else it is validated against
   # the literal values (enumerator) and/or patterns defined by calling {newvalues}.
   #
   # @param value [Object] the value to check for validity
   # @raise [ArgumentError] if the value is not valid
   # @return [void]
   # @api private
   #
   def unsafe_validate(value)
     self.class.value_collection.validate(value)
   end
 
   # Performs validation of the given value against the rules defined by this parameter.
   # @return [void]
   # @todo Better description of when the various exceptions are raised.ArgumentError is rescued and
   #   changed into Puppet::Error.
   # @raise [ArgumentError, TypeError, Puppet::DevError, Puppet::Error] under various conditions
   # A protected validation method that only ever raises useful exceptions.
   # @api public
   #
   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 #{self.name}: #{detail}", detail.backtrace
     end
   end
 
   # Sets the associated resource to nil.
   # @todo Why - what is the intent/purpose of this?
   # @return [nil]
   #
   def remove
     @resource = nil
   end
 
   # @return [Object] Gets the value of this parameter after performing any specified unmunging.
   def value
     unmunge(@value) unless @value.nil?
   end
 
   # Sets the given value as the value of this parameter.
   # @todo This original comment _"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)."_ does not seem to be correct, the implementation
   #   calls both validate and munge on the given value, so no late binding.
   #
   # The given value is validated and then munged (if munging has been specified). The result is store
   # as the value of this arameter.
   # @return [Object] The given `value` after munging.
   # @raise (see #validate)
   #
   def value=(value)
     validate(value)
 
     @value = munge(value)
   end
 
   # @return [Puppet::Provider] Returns the provider of the associated resource.
   # @todo The original comment says = _"Retrieve the resource's provider.
   #   Some types don't have providers, in which case we return the resource object itself."_
   #   This does not seem to be true, the default implementation that sets this value may be
   #   {Puppet::Type.provider=} which always gets either the name of a provider or an instance of one.
   #
   def provider
     @resource.provider
   end
 
   # @return [Array<Symbol>] Returns an array of the associated resource's symbolic tags (including the parameter itself).
   # Returns an array of the associated resource's symbolic tags (including the parameter itself).
   # At a minimun, the array contains the name of the parameter. If the associated resource
   # has tags, these tags are also included in the array.
   # @todo The original comment says = _"The properties need to return tags so that logs correctly
   #   collect them."_ what if anything of that is of interest to document. Should tags and their relationship
   #   to logs be described. This is a more general concept.
   #
   def tags
     unless defined?(@tags)
       @tags = []
       # This might not be true in testing
       @tags = @resource.tags if @resource.respond_to? :tags
       @tags << self.name.to_s
     end
     @tags
   end
 
   # @return [String] The name of the parameter in string form.
   def to_s
     name.to_s
   end
 
   # Produces a String with the value formatted for display to a human.
   # When the parameter value is a:
   #
   # * **single valued parameter value** the result is produced on the
   #   form `'value'` where _value_ is the string form of the parameter's value.
   #
   # * **Array** the list of values is enclosed in `[]`, and
   #   each produced value is separated by a comma.
   #
   # * **Hash** value is output with keys in sorted order enclosed in `{}` with each entry formatted
   #   on the form `'k' => v` where
   #   `k` is the key in string form and _v_ is the value of the key. Entries are comma separated.
   #
   # For both Array and Hash this method is called recursively to format contained values.
   # @note this method does not protect against infinite structures.
   #
   # @return [String] The formatted value in string form.
   #
   def self.format_value_for_display(value)
     if value.is_a? Array
       formatted_values = value.collect {|value| format_value_for_display(value)}.join(', ')
       "[#{formatted_values}]"
     elsif value.is_a? Hash
       # Sorting the hash keys for display is largely for having stable
       # output to test against, but also helps when scanning for hash
       # keys, since they will be in ASCIIbetical order.
       hash = value.keys.sort {|a,b| a.to_s <=> b.to_s}.collect do |k|
         "'#{k}' => #{format_value_for_display(value[k])}"
       end.join(', ')
 
       "{#{hash}}"
     else
       "'#{value}'"
     end
   end
 
   # @comment Document post_compile_hook here as it does not exist anywhere (called from type if implemented)
   # @!method post_compile_hook()
-  # @abstract A subclass may impliment this - it is not implemented in the Parameter class
-  # This method may be implemented by a parameter in order to perform final validations and actions in situations
-  # where the catalog needs to be fully completed but before the catalog is sent to the agent.
+  #   @abstract A subclass may implement this - it is not implemented in the Parameter class
+  #   This method may be implemented by a parameter in order to perform actions during compilation
+  #   after all resources have been added to the catalog.
+  #   @see Puppet::Type#finish
+  #   @see Puppet::Parser::Compiler#finish
 end
 
 require 'puppet/parameter/path'
diff --git a/spec/unit/type_spec.rb b/spec/unit/type_spec.rb
index a84ed12c2..9d83f3cb9 100755
--- a/spec/unit/type_spec.rb
+++ b/spec/unit/type_spec.rb
@@ -1,1045 +1,1045 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 
 describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   it "should be Comparable" do
     a = Puppet::Type.type(:notify).new(:name => "a")
     b = Puppet::Type.type(:notify).new(:name => "b")
     c = Puppet::Type.type(:notify).new(:name => "c")
 
     [[a, b, c], [a, c, b], [b, a, c], [b, c, a], [c, a, b], [c, b, a]].each do |this|
       this.sort.should == [a, b, c]
     end
 
     a.must be < b
     a.must be < c
     b.must be > a
     b.must be < c
     c.must be > a
     c.must be > b
 
     [a, b, c].each {|x| a.must be <= x }
     [a, b, c].each {|x| c.must be >= x }
 
     b.must be_between(a, c)
   end
 
   it "should consider a parameter to be valid if it is a valid parameter" do
     Puppet::Type.type(:mount).should be_valid_parameter(:name)
   end
 
   it "should consider a parameter to be valid if it is a valid property" do
     Puppet::Type.type(:mount).should be_valid_parameter(:fstype)
   end
 
   it "should consider a parameter to be valid if it is a valid metaparam" do
     Puppet::Type.type(:mount).should be_valid_parameter(:noop)
   end
 
   it "should be able to retrieve a property by name" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     resource.property(:fstype).must be_instance_of(Puppet::Type.type(:mount).attrclass(:fstype))
   end
 
   it "should be able to retrieve a parameter by name" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     resource.parameter(:name).must be_instance_of(Puppet::Type.type(:mount).attrclass(:name))
   end
 
   it "should be able to retrieve a property by name using the :parameter method" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     resource.parameter(:fstype).must be_instance_of(Puppet::Type.type(:mount).attrclass(:fstype))
   end
 
   it "should be able to retrieve all set properties" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     props = resource.properties
     props.should_not be_include(nil)
     [:fstype, :ensure, :pass].each do |name|
       props.should be_include(resource.parameter(name))
     end
   end
 
   it "can retrieve all set parameters" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present, :tag => 'foo')
     params = resource.parameters_with_value
     [:name, :provider, :ensure, :fstype, :pass, :dump, :target, :loglevel, :tag].each do |name|
       params.should be_include(resource.parameter(name))
     end
   end
 
   it "can not return any `nil` values when retrieving all set parameters" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present, :tag => 'foo')
     params = resource.parameters_with_value
     params.should_not be_include(nil)
   end
 
   it "can return an iterator for all set parameters" do
     resource = Puppet::Type.type(:notify).new(:name=>'foo',:message=>'bar',:tag=>'baz',:require=> "File['foo']")
     params = [:name, :message, :withpath, :loglevel, :tag, :require]
     resource.eachparameter { |param|
       params.should be_include(param.to_s.to_sym)
     }
   end
 
   it "should have a method for setting default values for resources" do
     Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:set_default)
   end
 
   it "should do nothing for attributes that have no defaults and no specified value" do
     Puppet::Type.type(:mount).new(:name => "foo").parameter(:noop).should be_nil
   end
 
   it "should have a method for adding tags" do
     Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:tags)
   end
 
   it "should use the tagging module" do
     Puppet::Type.type(:mount).ancestors.should be_include(Puppet::Util::Tagging)
   end
 
   it "should delegate to the tagging module when tags are added" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     resource.stubs(:tag).with(:mount)
 
     resource.expects(:tag).with(:tag1, :tag2)
 
     resource.tags = [:tag1,:tag2]
   end
 
   it "should add the current type as tag" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     resource.stubs(:tag)
 
     resource.expects(:tag).with(:mount)
 
     resource.tags = [:tag1,:tag2]
   end
 
   it "should have a method to know if the resource is exported" do
     Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:exported?)
   end
 
   it "should have a method to know if the resource is virtual" do
     Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:virtual?)
   end
 
   it "should consider its version to be zero if it has no catalog" do
     Puppet::Type.type(:mount).new(:name => "foo").version.should == 0
   end
 
   context "resource attributes" do
     let(:resource) {
       resource = Puppet::Type.type(:mount).new(:name => "foo")
       catalog = Puppet::Resource::Catalog.new
       catalog.version = 50
       catalog.add_resource resource
       resource
     }
 
     it "should consider its version to be its catalog version" do
       resource.version.should == 50
     end
 
     it "should have tags" do
       resource.tags.should == ["mount", "foo"]
     end
 
     it "should have a path" do
       resource.path.should == "/Mount[foo]"
     end
   end
 
   it "should consider its type to be the name of its class" do
     Puppet::Type.type(:mount).new(:name => "foo").type.should == :mount
   end
 
   it "should use any provided noop value" do
     Puppet::Type.type(:mount).new(:name => "foo", :noop => true).must be_noop
   end
 
   it "should use the global noop value if none is provided" do
     Puppet[:noop] = true
     Puppet::Type.type(:mount).new(:name => "foo").must be_noop
   end
 
   it "should not be noop if in a non-host_config catalog" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource resource
     resource.should_not be_noop
   end
 
   describe "when creating an event" do
     before do
       @resource = Puppet::Type.type(:mount).new :name => "foo"
     end
 
     it "should have the resource's reference as the resource" do
       @resource.event.resource.should == "Mount[foo]"
     end
 
     it "should have the resource's log level as the default log level" do
       @resource[:loglevel] = :warning
       @resource.event.default_log_level.should == :warning
     end
 
     {:file => "/my/file", :line => 50, :tags => %{foo bar}}.each do |attr, value|
       it "should set the #{attr}" do
         @resource.stubs(attr).returns value
         @resource.event.send(attr).should == value
       end
     end
 
     it "should allow specification of event attributes" do
       @resource.event(:status => "noop").status.should == "noop"
     end
   end
 
   describe "when creating a provider" do
     before :each do
       @type = Puppet::Type.newtype(:provider_test_type) do
         newparam(:name) { isnamevar }
         newparam(:foo)
         newproperty(:bar)
       end
     end
 
     after :each do
       @type.provider_hash.clear
     end
 
     describe "when determining if instances of the type are managed" do
       it "should not consider audit only resources to be managed" do
         @type.new(:name => "foo", :audit => 'all').managed?.should be_false
       end
 
       it "should not consider resources with only parameters to be managed" do
         @type.new(:name => "foo", :foo => 'did someone say food?').managed?.should be_false
       end
 
       it "should consider resources with any properties set to be managed" do
         @type.new(:name => "foo", :bar => 'Let us all go there').managed?.should be_true
       end
     end
 
     it "should have documentation for the 'provider' parameter if there are providers" do
       @type.provide(:test_provider)
       @type.paramdoc(:provider).should =~ /`provider_test_type`[\s\r]+resource/
     end
 
     it "should not have documentation for the 'provider' parameter if there are no providers" do
       expect { @type.paramdoc(:provider) }.to raise_error(NoMethodError)
     end
 
     it "should create a subclass of Puppet::Provider for the provider" do
       provider = @type.provide(:test_provider)
 
       provider.ancestors.should include(Puppet::Provider)
     end
 
     it "should use a parent class if specified" do
       parent_provider = @type.provide(:parent_provider)
       child_provider  = @type.provide(:child_provider, :parent => parent_provider)
 
       child_provider.ancestors.should include(parent_provider)
     end
 
     it "should use a parent class if specified by name" do
       parent_provider = @type.provide(:parent_provider)
       child_provider  = @type.provide(:child_provider, :parent => :parent_provider)
 
       child_provider.ancestors.should include(parent_provider)
     end
 
     it "should raise an error when the parent class can't be found" do
       expect {
         @type.provide(:child_provider, :parent => :parent_provider)
       }.to raise_error(Puppet::DevError, /Could not find parent provider.+parent_provider/)
     end
 
     it "should ensure its type has a 'provider' parameter" do
       @type.provide(:test_provider)
 
       @type.parameters.should include(:provider)
     end
 
     it "should remove a previously registered provider with the same name" do
       old_provider = @type.provide(:test_provider)
       new_provider = @type.provide(:test_provider)
 
       old_provider.should_not equal(new_provider)
     end
 
     it "should register itself as a provider for the type" do
       provider = @type.provide(:test_provider)
 
       provider.should == @type.provider(:test_provider)
     end
 
     it "should create a provider when a provider with the same name previously failed" do
       @type.provide(:test_provider) do
         raise "failed to create this provider"
       end rescue nil
 
       provider = @type.provide(:test_provider)
 
       provider.ancestors.should include(Puppet::Provider)
       provider.should == @type.provider(:test_provider)
     end
   end
 
   describe "when choosing a default provider" do
     it "should choose the provider with the highest specificity" do
       # Make a fake type
       type = Puppet::Type.newtype(:defaultprovidertest) do
         newparam(:name) do end
       end
 
       basic = type.provide(:basic) {}
       greater = type.provide(:greater) {}
 
       basic.stubs(:specificity).returns 1
       greater.stubs(:specificity).returns 2
 
       type.defaultprovider.should equal(greater)
     end
   end
 
   describe "when initializing" do
     describe "and passed a Puppet::Resource instance" do
       it "should set its title to the title of the resource if the resource type is equal to the current type" do
         resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "/other"})
         Puppet::Type.type(:mount).new(resource).title.should == "/foo"
       end
 
       it "should set its title to the resource reference if the resource type is not equal to the current type" do
         resource = Puppet::Resource.new(:user, "foo")
         Puppet::Type.type(:mount).new(resource).title.should == "User[foo]"
       end
 
       [:line, :file, :catalog, :exported, :virtual].each do |param|
         it "should copy '#{param}' from the resource if present" do
           resource = Puppet::Resource.new(:mount, "/foo")
           resource.send(param.to_s + "=", "foo")
           resource.send(param.to_s + "=", "foo")
           Puppet::Type.type(:mount).new(resource).send(param).should == "foo"
         end
       end
 
       it "should copy any tags from the resource" do
         resource = Puppet::Resource.new(:mount, "/foo")
         resource.tag "one", "two"
         tags = Puppet::Type.type(:mount).new(resource).tags
         tags.should be_include("one")
         tags.should be_include("two")
       end
 
       it "should copy the resource's parameters as its own" do
         resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:atboot => :yes, :fstype => "boo"})
         params = Puppet::Type.type(:mount).new(resource).to_hash
         params[:fstype].should == "boo"
         params[:atboot].should == :yes
       end
     end
 
     describe "and passed a Hash" do
       it "should extract the title from the hash" do
         Puppet::Type.type(:mount).new(:title => "/yay").title.should == "/yay"
       end
 
       it "should work when hash keys are provided as strings" do
         Puppet::Type.type(:mount).new("title" => "/yay").title.should == "/yay"
       end
 
       it "should work when hash keys are provided as symbols" do
         Puppet::Type.type(:mount).new(:title => "/yay").title.should == "/yay"
       end
 
       it "should use the name from the hash as the title if no explicit title is provided" do
         Puppet::Type.type(:mount).new(:name => "/yay").title.should == "/yay"
       end
 
       it "should use the Resource Type's namevar to determine how to find the name in the hash" do
         yay = make_absolute('/yay')
         Puppet::Type.type(:file).new(:path => yay).title.should == yay
       end
 
       [:catalog].each do |param|
         it "should extract '#{param}' from the hash if present" do
           Puppet::Type.type(:mount).new(:name => "/yay", param => "foo").send(param).should == "foo"
         end
       end
 
       it "should use any remaining hash keys as its parameters" do
         resource = Puppet::Type.type(:mount).new(:title => "/foo", :catalog => "foo", :atboot => :yes, :fstype => "boo")
         resource[:fstype].must == "boo"
         resource[:atboot].must == :yes
       end
     end
 
     it "should fail if any invalid attributes have been provided" do
       expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error, /Invalid parameter/)
     end
 
     context "when an attribute fails validation" do
       it "should fail with Puppet::ResourceError when PuppetError raised" do
         expect { Puppet::Type.type(:file).new(:title => "/foo", :source => "unknown:///") }.to raise_error(Puppet::ResourceError, /Parameter source failed on File\[.*foo\]/)
       end
 
       it "should fail with Puppet::ResourceError when ArgumentError raised" do
         expect { Puppet::Type.type(:file).new(:title => "/foo", :mode => "abcdef") }.to raise_error(Puppet::ResourceError, /Parameter mode failed on File\[.*foo\]/)
       end
 
       it "should include the file/line in the error" do
         Puppet::Type.type(:file).any_instance.stubs(:file).returns("example.pp")
         Puppet::Type.type(:file).any_instance.stubs(:line).returns(42)
         expect { Puppet::Type.type(:file).new(:title => "/foo", :source => "unknown:///") }.to raise_error(Puppet::ResourceError, /example.pp:42/)
       end
     end
 
     it "should set its name to the resource's title if the resource does not have a :name or namevar parameter set" do
       resource = Puppet::Resource.new(:mount, "/foo")
 
       Puppet::Type.type(:mount).new(resource).name.should == "/foo"
     end
 
     it "should fail if no title, name, or namevar are provided" do
       expect { Puppet::Type.type(:mount).new(:atboot => :yes) }.to raise_error(Puppet::Error)
     end
 
     it "should set the attributes in the order returned by the class's :allattrs method" do
       Puppet::Type.type(:mount).stubs(:allattrs).returns([:name, :atboot, :noop])
       resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "myname", :atboot => :yes, :noop => "whatever"})
 
       set = []
 
       Puppet::Type.type(:mount).any_instance.stubs(:newattr).with do |param, hash|
         set << param
         true
       end.returns(stub_everything("a property"))
 
       Puppet::Type.type(:mount).new(resource)
 
       set[-1].should == :noop
       set[-2].should == :atboot
     end
 
     it "should always set the name and then default provider before anything else" do
       Puppet::Type.type(:mount).stubs(:allattrs).returns([:provider, :name, :atboot])
       resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "myname", :atboot => :yes})
 
       set = []
 
       Puppet::Type.type(:mount).any_instance.stubs(:newattr).with do |param, hash|
         set << param
         true
       end.returns(stub_everything("a property"))
 
       Puppet::Type.type(:mount).new(resource)
       set[0].should == :name
       set[1].should == :provider
     end
 
     # This one is really hard to test :/
     it "should set each default immediately if no value is provided" do
       defaults = []
       Puppet::Type.type(:service).any_instance.stubs(:set_default).with { |value| defaults << value; true }
 
       Puppet::Type.type(:service).new :name => "whatever"
 
       defaults[0].should == :provider
     end
 
     it "should retain a copy of the originally provided parameters" do
       Puppet::Type.type(:mount).new(:name => "foo", :atboot => :yes, :noop => false).original_parameters.should == {:atboot => :yes, :noop => false}
     end
 
     it "should delete the name via the namevar from the originally provided parameters" do
       Puppet::Type.type(:file).new(:name => make_absolute('/foo')).original_parameters[:path].should be_nil
     end
 
     context "when validating the resource" do
       it "should call the type's validate method if present" do
         Puppet::Type.type(:file).any_instance.expects(:validate)
         Puppet::Type.type(:file).new(:name => make_absolute('/foo'))
       end
 
       it "should raise Puppet::ResourceError with resource name when Puppet::Error raised" do
         expect do
           Puppet::Type.type(:file).new(
             :name => make_absolute('/foo'),
             :source => "puppet:///",
             :content => "foo"
           )
         end.to raise_error(Puppet::ResourceError, /Validation of File\[.*foo.*\]/)
       end
 
       it "should raise Puppet::ResourceError with manifest file and line on failure" do
         Puppet::Type.type(:file).any_instance.stubs(:file).returns("example.pp")
         Puppet::Type.type(:file).any_instance.stubs(:line).returns(42)
         expect do
           Puppet::Type.type(:file).new(
             :name => make_absolute('/foo'),
             :source => "puppet:///",
             :content => "foo"
           )
         end.to raise_error(Puppet::ResourceError, /Validation.*example.pp:42/)
       end
     end
   end
 
   describe "when #finish is called on a type" do
     let(:post_hook_type) do
       Puppet::Type.newtype(:finish_test) do
         newparam(:name) { isnamevar }
 
         newparam(:post) do
           def post_compile_hook
             raise "post_compile hook ran"
           end
         end
       end
     end
 
-    let(:post_hook_resource) do 
+    let(:post_hook_resource) do
       post_hook_type.new(:name => 'foo',:post => 'fake_value')
     end
 
     it "should call #post_compile_hook on parameters that implement it" do
-      expect { post_hook_resource.finish }.to raise_exception(RuntimeError ,"post_compile hook ran")
+      expect { post_hook_resource.finish }.to raise_error(RuntimeError, "post_compile hook ran")
     end
   end
 
   it "should have a class method for converting a hash into a Puppet::Resource instance" do
     Puppet::Type.type(:mount).must respond_to(:hash2resource)
   end
 
   describe "when converting a hash to a Puppet::Resource instance" do
     before do
       @type = Puppet::Type.type(:mount)
     end
 
     it "should treat a :title key as the title of the resource" do
       @type.hash2resource(:name => "/foo", :title => "foo").title.should == "foo"
     end
 
     it "should use the name from the hash as the title if no explicit title is provided" do
       @type.hash2resource(:name => "foo").title.should == "foo"
     end
 
     it "should use the Resource Type's namevar to determine how to find the name in the hash" do
       @type.stubs(:key_attributes).returns([ :myname ])
 
       @type.hash2resource(:myname => "foo").title.should == "foo"
     end
 
     [:catalog].each do |attr|
       it "should use any provided #{attr}" do
         @type.hash2resource(:name => "foo", attr => "eh").send(attr).should == "eh"
       end
     end
 
     it "should set all provided parameters on the resource" do
       @type.hash2resource(:name => "foo", :fstype => "boo", :boot => "fee").to_hash.should == {:name => "foo", :fstype => "boo", :boot => "fee"}
     end
 
     it "should not set the title as a parameter on the resource" do
       @type.hash2resource(:name => "foo", :title => "eh")[:title].should be_nil
     end
 
     it "should not set the catalog as a parameter on the resource" do
       @type.hash2resource(:name => "foo", :catalog => "eh")[:catalog].should be_nil
     end
 
     it "should treat hash keys equivalently whether provided as strings or symbols" do
       resource = @type.hash2resource("name" => "foo", "title" => "eh", "fstype" => "boo")
       resource.title.should == "eh"
       resource[:name].should == "foo"
       resource[:fstype].should == "boo"
     end
   end
 
   describe "when retrieving current property values" do
     before do
       @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
       @resource.property(:ensure).stubs(:retrieve).returns :absent
     end
 
     it "should fail if its provider is unsuitable" do
       @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
       @resource.provider.class.expects(:suitable?).returns false
       expect { @resource.retrieve_resource }.to raise_error(Puppet::Error)
     end
 
     it "should return a Puppet::Resource instance with its type and title set appropriately" do
       result = @resource.retrieve_resource
       result.should be_instance_of(Puppet::Resource)
       result.type.should == "Mount"
       result.title.should == "foo"
     end
 
     it "should set the name of the returned resource if its own name and title differ" do
       @resource[:name] = "myname"
       @resource.title = "other name"
       @resource.retrieve_resource[:name].should == "myname"
     end
 
     it "should provide a value for all set properties" do
       values = @resource.retrieve_resource
       [:ensure, :fstype, :pass].each { |property| values[property].should_not be_nil }
     end
 
     it "should provide a value for 'ensure' even if no desired value is provided" do
       @resource = Puppet::Type.type(:file).new(:path => make_absolute("/my/file/that/can't/exist"))
     end
 
     it "should not call retrieve on non-ensure properties if the resource is absent and should consider the property absent" do
       @resource.property(:ensure).expects(:retrieve).returns :absent
       @resource.property(:fstype).expects(:retrieve).never
       @resource.retrieve_resource[:fstype].should == :absent
     end
 
     it "should include the result of retrieving each property's current value if the resource is present" do
       @resource.property(:ensure).expects(:retrieve).returns :present
       @resource.property(:fstype).expects(:retrieve).returns 15
       @resource.retrieve_resource[:fstype] == 15
     end
   end
 
   describe "#to_resource" do
     it "should return a Puppet::Resource that includes properties, parameters and tags" do
       type_resource = Puppet::Type.type(:mount).new(
         :ensure   => :present,
         :name     => "foo",
         :fstype   => "bar",
         :remounts => true
       )
       type_resource.tags = %w{bar baz}
 
       # If it's not a property it's a parameter
       type_resource.parameters[:remounts].should_not be_a(Puppet::Property)
       type_resource.parameters[:fstype].is_a?(Puppet::Property).should be_true
 
       type_resource.property(:ensure).expects(:retrieve).returns :present
       type_resource.property(:fstype).expects(:retrieve).returns 15
 
       resource = type_resource.to_resource
 
       resource.should be_a Puppet::Resource
       resource[:fstype].should   == 15
       resource[:remounts].should == :true
       resource.tags.should       =~ %w{foo bar baz mount}
     end
   end
 
   describe ".title_patterns" do
     describe "when there's one namevar" do
       before do
         @type_class = Puppet::Type.type(:notify)
         @type_class.stubs(:key_attributes).returns([:one])
       end
 
       it "should have a default pattern for when there's one namevar" do
         patterns = @type_class.title_patterns
         patterns.length.should == 1
         patterns[0].length.should == 2
       end
 
       it "should have a regexp that captures the entire string" do
         patterns = @type_class.title_patterns
         string = "abc\n\tdef"
         patterns[0][0] =~ string
         $1.should == "abc\n\tdef"
       end
     end
   end
 
   describe "when in a catalog" do
     before do
       @catalog = Puppet::Resource::Catalog.new
       @container = Puppet::Type.type(:component).new(:name => "container")
       @one = Puppet::Type.type(:file).new(:path => make_absolute("/file/one"))
       @two = Puppet::Type.type(:file).new(:path => make_absolute("/file/two"))
 
       @catalog.add_resource @container
       @catalog.add_resource @one
       @catalog.add_resource @two
       @catalog.add_edge @container, @one
       @catalog.add_edge @container, @two
     end
 
     it "should have no parent if there is no in edge" do
       @container.parent.should be_nil
     end
 
     it "should set its parent to its in edge" do
       @one.parent.ref.should == @container.ref
     end
 
     after do
       @catalog.clear(true)
     end
   end
 
   it "should have a 'stage' metaparam" do
     Puppet::Type.metaparamclass(:stage).should be_instance_of(Class)
   end
 
   describe "#suitable?" do
     let(:type) { Puppet::Type.type(:file) }
     let(:resource) { type.new :path => tmpfile('suitable') }
     let(:provider) { resource.provider }
 
     it "should be suitable if its type doesn't use providers" do
       type.stubs(:paramclass).with(:provider).returns nil
       resource.must be_suitable
     end
 
     it "should be suitable if it has a provider which is suitable" do
       resource.must be_suitable
     end
 
     it "should not be suitable if it has a provider which is not suitable" do
       provider.class.stubs(:suitable?).returns false
       resource.should_not be_suitable
     end
 
     it "should be suitable if it does not have a provider and there is a default provider" do
       resource.stubs(:provider).returns nil
       resource.must be_suitable
     end
 
     it "should not be suitable if it doesn't have a provider and there is not default provider" do
       resource.stubs(:provider).returns nil
       type.stubs(:defaultprovider).returns nil
 
       resource.should_not be_suitable
     end
   end
 
   describe "::instances" do
     after :each do Puppet::Type.rmtype(:type_spec_fake_type) end
     let :type do
       Puppet::Type.newtype(:type_spec_fake_type) do
         newparam(:name) do
           isnamevar
         end
 
         newproperty(:prop1) {}
       end
 
       Puppet::Type.type(:type_spec_fake_type)
     end
 
     it "should not fail if no suitable providers are found" do
       type.provide(:fake1) do
         confine :exists => '/no/such/file'
         mk_resource_methods
       end
 
       expect { type.instances.should == [] }.to_not raise_error
     end
 
     context "with a default provider" do
       before :each do
         type.provide(:default) do
           defaultfor :operatingsystem => Facter.value(:operatingsystem)
           mk_resource_methods
           class << self
             attr_accessor :names
           end
           def self.instance(name)
             new(:name => name, :ensure => :present)
           end
           def self.instances
             @instances ||= names.collect { |name| instance(name.to_s) }
           end
 
           @names = [:one, :two]
         end
       end
 
       it "should return only instances of the type" do
         type.instances.should be_all {|x| x.is_a? type }
       end
 
       it "should return instances from the default provider" do
         type.instances.map(&:name).should == ["one", "two"]
       end
 
       it "should return instances from all providers" do
         type.provide(:fake1, :parent => :default) { @names = [:three, :four] }
         type.instances.map(&:name).should == ["one", "two", "three", "four"]
       end
 
       it "should not return instances from unsuitable providers" do
         type.provide(:fake1, :parent => :default) do
           @names = [:three, :four]
           confine :exists => "/no/such/file"
         end
 
         type.instances.map(&:name).should == ["one", "two"]
       end
     end
   end
 
 
   describe "::ensurable?" do
     before :each do
       class TestEnsurableType < Puppet::Type
         def exists?; end
         def create; end
         def destroy; end
       end
     end
 
     it "is true if the class has exists?, create, and destroy methods defined" do
       TestEnsurableType.should be_ensurable
     end
 
     it "is false if exists? is not defined" do
       TestEnsurableType.class_eval { remove_method(:exists?) }
       TestEnsurableType.should_not be_ensurable
     end
 
     it "is false if create is not defined" do
       TestEnsurableType.class_eval { remove_method(:create) }
       TestEnsurableType.should_not be_ensurable
     end
 
     it "is false if destroy is not defined" do
       TestEnsurableType.class_eval { remove_method(:destroy) }
       TestEnsurableType.should_not be_ensurable
     end
   end
 end
 
 describe Puppet::Type::RelationshipMetaparam do
   include PuppetSpec::Files
 
   it "should be a subclass of Puppet::Parameter" do
     Puppet::Type::RelationshipMetaparam.superclass.should equal(Puppet::Parameter)
   end
 
   it "should be able to produce a list of subclasses" do
     Puppet::Type::RelationshipMetaparam.should respond_to(:subclasses)
   end
 
   describe "when munging relationships" do
     before do
       @path = File.expand_path('/foo')
       @resource = Puppet::Type.type(:file).new :name => @path
       @metaparam = Puppet::Type.metaparamclass(:require).new :resource => @resource
     end
 
     it "should accept Puppet::Resource instances" do
       ref = Puppet::Resource.new(:file, @path)
       @metaparam.munge(ref)[0].should equal(ref)
     end
 
     it "should turn any string into a Puppet::Resource" do
       @metaparam.munge("File[/ref]")[0].should be_instance_of(Puppet::Resource)
     end
   end
 
   it "should be able to validate relationships" do
     Puppet::Type.metaparamclass(:require).new(:resource => mock("resource")).should respond_to(:validate_relationship)
   end
 
   describe 'if any specified resource is not in the catalog' do
     let(:catalog) { mock 'catalog' }
 
     let(:resource) do
       stub 'resource',
         :catalog => catalog,
         :ref     => 'resource',
         :line=   => nil,
         :file=   => nil
     end
 
     let(:param) { Puppet::Type.metaparamclass(:require).new(:resource => resource, :value => %w{Foo[bar] Class[test]}) }
 
     before do
       catalog.expects(:resource).with("Foo[bar]").returns "something"
       catalog.expects(:resource).with("Class[Test]").returns nil
     end
 
     describe "and the resource doesn't have a file or line number" do
       it "raises an error" do
         expect { param.validate_relationship }.to raise_error do |error|
           error.should be_a Puppet::ResourceError
           error.message.should match %r[Class\[Test\]]
         end
       end
     end
 
     describe "and the resource has a file or line number" do
       before do
         resource.stubs(:line).returns '42'
         resource.stubs(:file).returns '/hitchhikers/guide/to/the/galaxy'
       end
 
       it "raises an error with context" do
         expect { param.validate_relationship }.to raise_error do |error|
           error.should be_a Puppet::ResourceError
           error.message.should match %r[Class\[Test\]]
           error.message.should match %r["in /hitchhikers/guide/to/the/galaxy:42"]
         end
       end
     end
   end
 end
 
 describe Puppet::Type.metaparamclass(:audit) do
   include PuppetSpec::Files
 
   before do
     @resource = Puppet::Type.type(:file).new :path => make_absolute('/foo')
   end
 
   it "should default to being nil" do
     @resource[:audit].should be_nil
   end
 
   it "should specify all possible properties when asked to audit all properties" do
     @resource[:audit] = :all
 
     list = @resource.class.properties.collect { |p| p.name }
     @resource[:audit].should == list
   end
 
   it "should accept the string 'all' to specify auditing all possible properties" do
     @resource[:audit] = 'all'
 
     list = @resource.class.properties.collect { |p| p.name }
     @resource[:audit].should == list
   end
 
   it "should fail if asked to audit an invalid property" do
     expect { @resource[:audit] = :foobar }.to raise_error(Puppet::Error)
   end
 
   it "should create an attribute instance for each auditable property" do
     @resource[:audit] = :mode
     @resource.parameter(:mode).should_not be_nil
   end
 
   it "should accept properties specified as a string" do
     @resource[:audit] = "mode"
     @resource.parameter(:mode).should_not be_nil
   end
 
   it "should not create attribute instances for parameters, only properties" do
     @resource[:audit] = :noop
     @resource.parameter(:noop).should be_nil
   end
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
       Puppet::Type.type(:file).stubs(:key_attributes).returns [:path, :mode, :owner]
       Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       myfile = make_absolute('/my/file')
       res = Puppet::Type.type(:file).new( :title => myfile, :path => myfile, :owner => 'root', :content => 'hello' )
       res.uniqueness_key.should == [ nil, 'root', myfile]
     end
   end
 
   context "type attribute bracket methods" do
     after :each do Puppet::Type.rmtype(:attributes)     end
     let   :type do
       Puppet::Type.newtype(:attributes) do
         newparam(:name) {}
       end
     end
 
     it "should work with parameters" do
       type.newparam(:param) {}
       instance = type.new(:name => 'test')
 
       expect { instance[:param] = true }.to_not raise_error
       expect { instance["param"] = true }.to_not raise_error
       instance[:param].should == true
       instance["param"].should == true
     end
 
     it "should work with meta-parameters" do
       instance = type.new(:name => 'test')
 
       expect { instance[:noop] = true }.to_not raise_error
       expect { instance["noop"] = true }.to_not raise_error
       instance[:noop].should == true
       instance["noop"].should == true
     end
 
     it "should work with properties" do
       type.newproperty(:property) {}
       instance = type.new(:name => 'test')
 
       expect { instance[:property] = true }.to_not raise_error
       expect { instance["property"] = true }.to_not raise_error
       instance.property(:property).must be
       instance.should(:property).must be_true
     end
 
     it "should handle proprieties correctly" do
       # Order of assignment is significant in this test.
       props = {}
       [:one, :two, :three].each {|prop| type.newproperty(prop) {} }
       instance = type.new(:name => "test")
 
       instance[:one] = "boo"
       one = instance.property(:one)
       instance.properties.must == [one]
 
       instance[:three] = "rah"
       three = instance.property(:three)
       instance.properties.must == [one, three]
 
       instance[:two] = "whee"
       two = instance.property(:two)
       instance.properties.must == [one, two, three]
     end
 
     it "newattr should handle required features correctly" do
       Puppet::Util::Log.level = :debug
 
       type.feature :feature1, "one"
       type.feature :feature2, "two"
 
       none = type.newproperty(:none) {}
       one  = type.newproperty(:one, :required_features => :feature1) {}
       two  = type.newproperty(:two, :required_features => [:feature1, :feature2]) {}
 
       nope  = type.provide(:nope)  {}
       maybe = type.provide(:maybe) { has_features :feature1 }
       yep   = type.provide(:yep)   { has_features :feature1, :feature2 }
 
       [nope, maybe, yep].each_with_index do |provider, i|
         rsrc = type.new(:provider => provider.name, :name => "test#{i}",
                         :none => "a", :one => "b", :two => "c")
 
         rsrc.should(:none).must be
 
         if provider.declared_feature? :feature1
           rsrc.should(:one).must be
         else
           rsrc.should(:one).must_not be
           @logs.find {|l| l.message =~ /not managing attribute one/ }.should be
         end
 
         if provider.declared_feature? :feature2
           rsrc.should(:two).must be
         else
           rsrc.should(:two).must_not be
           @logs.find {|l| l.message =~ /not managing attribute two/ }.should be
         end
       end
     end
   end
 end