diff --git a/lib/puppet/resource/catalog.rb b/lib/puppet/resource/catalog.rb
index 87354a46d..0dac7308b 100644
--- a/lib/puppet/resource/catalog.rb
+++ b/lib/puppet/resource/catalog.rb
@@ -1,656 +1,656 @@
 require 'puppet/node'
 require 'puppet/indirector'
 require 'puppet/simple_graph'
 require 'puppet/transaction'
 
 require 'puppet/util/pson'
 
 require 'puppet/util/tagging'
 
 # This class models a node catalog.  It is the thing
 # meant to be passed from server to client, and it contains all
 # of the information in the catalog, including the resources
 # and the relationships between them.
 class Puppet::Resource::Catalog < Puppet::SimpleGraph
   class DuplicateResourceError < Puppet::Error; end
 
   extend Puppet::Indirector
   indirects :catalog, :terminus_setting => :catalog_terminus
 
   include Puppet::Util::Tagging
   extend Puppet::Util::Pson
 
   # The host name this is a catalog for.
   attr_accessor :name
 
   # The catalog version.  Used for testing whether a catalog
   # is up to date.
   attr_accessor :version
 
   # How long this catalog took to retrieve.  Used for reporting stats.
   attr_accessor :retrieval_duration
 
   # Whether this is a host catalog, which behaves very differently.
   # In particular, reports are sent, graphs are made, and state is
   # stored in the state database.  If this is set incorrectly, then you often
   # end up in infinite loops, because catalogs are used to make things
   # that the host catalog needs.
   attr_accessor :host_config
 
   # Whether this catalog was retrieved from the cache, which affects
   # whether it is written back out again.
   attr_accessor :from_cache
 
   # Some metadata to help us compile and generally respond to the current state.
   attr_accessor :client_version, :server_version
 
   # Add classes to our class list.
   def add_class(*classes)
     classes.each do |klass|
       @classes << klass
     end
 
     # Add the class names as tags, too.
     tag(*classes)
   end
 
   def title_key_for_ref( ref )
     ref =~ /^([-\w:]+)\[(.*)\]$/m
     [$1, $2]
   end
 
   # Add a resource to our graph and to our resource table.
   # This is actually a relatively complicated method, because it handles multiple
   # aspects of Catalog behaviour:
   # * Add the resource to the resource table
   # * Add the resource to the resource graph
   # * Add the resource to the relationship graph
   # * Add any aliases that make sense for the resource (e.g., name != title)
   def add_resource(*resource)
     add_resource(*resource[0..-2]) if resource.length > 1
     resource = resource.pop
     raise ArgumentError, "Can only add objects that respond to :ref, not instances of #{resource.class}" unless resource.respond_to?(:ref)
     fail_on_duplicate_type_and_title(resource)
     title_key = title_key_for_ref(resource.ref)
 
     @transient_resources << resource if applying?
     @resource_table[title_key] = resource
 
     # If the name and title differ, set up an alias
 
     if resource.respond_to?(:name) and resource.respond_to?(:title) and resource.respond_to?(:isomorphic?) and resource.name != resource.title
       self.alias(resource, resource.uniqueness_key) if resource.isomorphic?
     end
 
     resource.catalog = self if resource.respond_to?(:catalog=)
     add_vertex(resource)
     @relationship_graph.add_vertex(resource) if @relationship_graph
   end
 
   # Create an alias for a resource.
   def alias(resource, key)
     resource.ref =~ /^(.+)\[/
     class_name = $1 || resource.class.name
 
     newref = [class_name, key].flatten
 
     if key.is_a? String
       ref_string = "#{class_name}[#{key}]"
       return if ref_string == resource.ref
     end
 
     # LAK:NOTE It's important that we directly compare the references,
     # because sometimes an alias is created before the resource is
     # added to the catalog, so comparing inside the below if block
     # isn't sufficient.
     if existing = @resource_table[newref]
       return if existing == resource
       resource_definition = " at #{resource.file}:#{resource.line}" if resource.file and resource.line
       existing_definition = " at #{existing.file}:#{existing.line}" if existing.file and existing.line
       msg = "Cannot alias #{resource.ref} to #{key.inspect}#{resource_definition}; resource #{newref.inspect} already defined#{existing_definition}"
       raise ArgumentError, msg
     end
     @resource_table[newref] = resource
     @aliases[resource.ref] ||= []
     @aliases[resource.ref] << newref
   end
 
   # Apply our catalog to the local host.  Valid options
   # are:
   #   :tags - set the tags that restrict what resources run
   #       during the transaction
   #   :ignoreschedules - tell the transaction to ignore schedules
   #       when determining the resources to run
   def apply(options = {})
     @applying = true
 
     Puppet::Util::Storage.load if host_config?
 
     transaction = Puppet::Transaction.new(self, options[:report])
     register_report = options[:report].nil?
 
     transaction.tags = options[:tags] if options[:tags]
     transaction.ignoreschedules = true if options[:ignoreschedules]
     transaction.for_network_device = options[:network_device]
 
     transaction.add_times :config_retrieval => self.retrieval_duration || 0
 
     begin
       Puppet::Util::Log.newdestination(transaction.report) if register_report
       begin
         transaction.evaluate
       ensure
         Puppet::Util::Log.close(transaction.report) if register_report
       end
     rescue Puppet::Error => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Could not apply complete catalog: #{detail}"
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Got an uncaught exception of type #{detail.class}: #{detail}"
     ensure
       # Don't try to store state unless we're a host config
       # too recursive.
       Puppet::Util::Storage.store if host_config?
     end
 
     yield transaction if block_given?
 
     return transaction
   ensure
     @applying = false
   end
 
   # Are we in the middle of applying the catalog?
   def applying?
     @applying
   end
 
   def clear(remove_resources = true)
     super()
     # We have to do this so that the resources clean themselves up.
     @resource_table.values.each { |resource| resource.remove } if remove_resources
     @resource_table.clear
 
     if @relationship_graph
       @relationship_graph.clear
       @relationship_graph = nil
     end
   end
 
   def classes
     @classes.dup
   end
 
   # Create a new resource and register it in the catalog.
   def create_resource(type, options)
     unless klass = Puppet::Type.type(type)
       raise ArgumentError, "Unknown resource type #{type}"
     end
     return unless resource = klass.new(options)
 
     add_resource(resource)
     resource
   end
 
   # Turn our catalog graph into an old-style tree of TransObjects and TransBuckets.
   # LAK:NOTE(20081211): This is a  pre-0.25 backward compatibility method.
   # It can be removed as soon as xmlrpc is killed.
   def extract
     top = nil
     current = nil
     buckets = {}
 
     unless main = resource(:stage, "main")
       raise Puppet::DevError, "Could not find 'main' stage; cannot generate catalog"
     end
 
     if stages = vertices.find_all { |v| v.type == "Stage" and v.title != "main" } and ! stages.empty?
       Puppet.warning "Stages are not supported by 0.24.x client; stage(s) #{stages.collect { |s| s.to_s }.join(', ') } will be ignored"
     end
 
     bucket = nil
     walk(main, :out) do |source, target|
       # The sources are always non-builtins.
       unless tmp = buckets[source.to_s]
         if tmp = buckets[source.to_s] = source.to_trans
           bucket = tmp
         else
           # This is because virtual resources return nil.  If a virtual
           # container resource contains realized resources, we still need to get
           # to them.  So, we keep a reference to the last valid bucket
           # we returned and use that if the container resource is virtual.
         end
       end
       bucket = tmp || bucket
       if child = target.to_trans
         raise "No bucket created for #{source}" unless bucket
         bucket.push child
 
         # It's important that we keep a reference to any TransBuckets we've created, so
         # we don't create multiple buckets for children.
         buckets[target.to_s] = child unless target.builtin?
       end
     end
 
     # Retrieve the bucket for the top-level scope and set the appropriate metadata.
     unless result = buckets[main.to_s]
       # This only happens when the catalog is entirely empty.
       result = buckets[main.to_s] = main.to_trans
     end
 
     result.classes = classes
 
     # Clear the cache to encourage the GC
     buckets.clear
     result
   end
 
   # Make sure all of our resources are "finished".
   def finalize
     make_default_resources
 
     @resource_table.values.each { |resource| resource.finish }
 
     write_graph(:resources)
   end
 
   def host_config?
     host_config
   end
 
   def initialize(name = nil)
     super()
     @name = name if name
     @classes = []
     @resource_table = {}
     @transient_resources = []
     @applying = false
     @relationship_graph = nil
 
     @host_config = true
 
     @aliases = {}
 
     if block_given?
       yield(self)
       finalize
     end
   end
 
   # Make the default objects necessary for function.
   def make_default_resources
     # We have to add the resources to the catalog, or else they won't get cleaned up after
     # the transaction.
 
     # First create the default scheduling objects
     Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
 
     # And filebuckets
     if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
       add_resource(bucket) unless resource(bucket.ref)
     end
   end
 
   # Create a graph of all of the relationships in our catalog.
   def relationship_graph
     unless @relationship_graph
       # It's important that we assign the graph immediately, because
       # the debug messages below use the relationships in the
       # relationship graph to determine the path to the resources
       # spitting out the messages.  If this is not set,
       # then we get into an infinite loop.
       @relationship_graph = Puppet::SimpleGraph.new
 
       # First create the dependency graph
       self.vertices.each do |vertex|
         @relationship_graph.add_vertex vertex
         vertex.builddepends.each do |edge|
           @relationship_graph.add_edge(edge)
         end
       end
 
       # Lastly, add in any autorequires
       @relationship_graph.vertices.each do |vertex|
         vertex.autorequire(self).each do |edge|
           unless @relationship_graph.edge?(edge.source, edge.target) # don't let automatic relationships conflict with manual ones.
             unless @relationship_graph.edge?(edge.target, edge.source)
               vertex.debug "Autorequiring #{edge.source}"
               @relationship_graph.add_edge(edge)
             else
               vertex.debug "Skipping automatic relationship with #{(edge.source == vertex ? edge.target : edge.source)}"
             end
           end
         end
       end
       @relationship_graph.write_graph(:relationships) if host_config?
 
       # Then splice in the container information
       splice!(@relationship_graph)
 
       @relationship_graph.write_graph(:expanded_relationships) if host_config?
     end
     @relationship_graph
   end
 
   # Impose our container information on another graph by using it
   # to replace any container vertices X with a pair of verticies
   # { admissible_X and completed_X } such that that
   #
   #    0) completed_X depends on admissible_X
   #    1) contents of X each depend on admissible_X
   #    2) completed_X depends on each on the contents of X
   #    3) everything which depended on X depens on completed_X
   #    4) admissible_X depends on everything X depended on
   #    5) the containers and their edges must be removed
   #
   # Note that this requires attention to the possible case of containers
   # which contain or depend on other containers, but has the advantage
   # that the number of new edges created scales linearly with the number
   # of contained verticies regardless of how containers are related;
   # alternatives such as replacing container-edges with content-edges
   # scale as the product of the number of external dependences, which is
   # to say geometrically in the case of nested / chained containers.
   #
   Default_label = { :callback => :refresh, :event => :ALL_EVENTS }
   def splice!(other)
     stage_class      = Puppet::Type.type(:stage)
     whit_class       = Puppet::Type.type(:whit)
     component_class  = Puppet::Type.type(:component)
     containers = vertices.find_all { |v| (v.is_a?(component_class) or v.is_a?(stage_class)) and vertex?(v) }
     #
     # These two hashes comprise the aforementioned attention to the possible
     #   case of containers that contain / depend on other containers; they map
     #   containers to their sentinals but pass other verticies through.  Thus we
     #   can "do the right thing" for references to other verticies that may or
     #   may not be containers.
     #
     admissible = Hash.new { |h,k| k }
     completed  = Hash.new { |h,k| k }
     containers.each { |x|
       admissible[x] = whit_class.new(:name => "admissible_#{x.ref}", :catalog => self)
       completed[x]  = whit_class.new(:name => "completed_#{x.ref}",  :catalog => self)
     }
     #
     # Implement the six requierments listed above
     #
     containers.each { |x|
       contents = adjacent(x, :direction => :out)
       other.add_edge(admissible[x],completed[x]) if contents.empty? # (0)
       contents.each { |v|
         other.add_edge(admissible[x],admissible[v],Default_label) # (1)
         other.add_edge(completed[v], completed[x], Default_label) # (2)
       }
       # (3) & (5)
       other.adjacent(x,:direction => :in,:type => :edges).each { |e|
         other.add_edge(completed[e.source],admissible[x],e.label)
         other.remove_edge! e
       }
       # (4) & (5)
       other.adjacent(x,:direction => :out,:type => :edges).each { |e|
         other.add_edge(completed[x],admissible[e.target],e.label)
         other.remove_edge! e
       }
     }
     containers.each { |x| other.remove_vertex! x } # (5)
   end
 
   # Remove the resource from our catalog.  Notice that we also call
   # 'remove' on the resource, at least until resource classes no longer maintain
   # references to the resource instances.
   def remove_resource(*resources)
     resources.each do |resource|
       @resource_table.delete(resource.ref)
       if aliases = @aliases[resource.ref]
         aliases.each { |res_alias| @resource_table.delete(res_alias) }
         @aliases.delete(resource.ref)
       end
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
       resource.remove
     end
   end
 
   # Look a resource up by its reference (e.g., File[/etc/passwd]).
   def resource(type, title = nil)
     # Always create a resource reference, so that it always canonizes how we
     # are referring to them.
     if title
       res = Puppet::Resource.new(type, title)
     else
       # If they didn't provide a title, then we expect the first
       # argument to be of the form 'Class[name]', which our
       # Reference class canonizes for us.
       res = Puppet::Resource.new(nil, type)
     end
     title_key      = [res.type, res.title.to_s]
     uniqueness_key = [res.type, res.uniqueness_key].flatten
     @resource_table[title_key] || @resource_table[uniqueness_key]
   end
 
   def resource_refs
     resource_keys.collect{ |type, name| name.is_a?( String ) ? "#{type}[#{name}]" : nil}.compact
   end
 
   def resource_keys
     @resource_table.keys
   end
 
   def resources
     @resource_table.values.uniq
   end
 
   def self.from_pson(data)
     result = new(data['name'])
 
     if tags = data['tags']
       result.tag(*tags)
     end
 
     if version = data['version']
       result.version = version
     end
 
     if resources = data['resources']
       resources = PSON.parse(resources) if resources.is_a?(String)
       resources.each do |res|
         resource_from_pson(result, res)
       end
     end
 
     if edges = data['edges']
       edges = PSON.parse(edges) if edges.is_a?(String)
       edges.each do |edge|
         edge_from_pson(result, edge)
       end
     end
 
     if classes = data['classes']
       result.add_class(*classes)
     end
 
     result
   end
 
   def self.edge_from_pson(result, edge)
     # If no type information was presented, we manually find
     # the class.
     edge = Puppet::Relationship.from_pson(edge) if edge.is_a?(Hash)
     unless source = result.resource(edge.source)
       raise ArgumentError, "Could not convert from pson: Could not find relationship source #{edge.source.inspect}"
     end
     edge.source = source
 
     unless target = result.resource(edge.target)
       raise ArgumentError, "Could not convert from pson: Could not find relationship target #{edge.target.inspect}"
     end
     edge.target = target
 
     result.add_edge(edge)
   end
 
   def self.resource_from_pson(result, res)
     res = Puppet::Resource.from_pson(res) if res.is_a? Hash
     result.add_resource(res)
   end
 
   PSON.register_document_type('Catalog',self)
   def to_pson_data_hash
     {
       'document_type' => 'Catalog',
       'data'       => {
         'tags'      => tags,
         'name'      => name,
         'version'   => version,
         'resources' => vertices.collect { |v| v.to_pson_data_hash },
         'edges'     => edges.   collect { |e| e.to_pson_data_hash },
         'classes'   => classes
         },
       'metadata' => {
         'api_version' => 1
         }
     }
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Convert our catalog into a RAL catalog.
   def to_ral
     to_catalog :to_ral
   end
 
   # Convert our catalog into a catalog of Puppet::Resource instances.
   def to_resource
     to_catalog :to_resource
   end
 
   # filter out the catalog, applying +block+ to each resource.
   # If the block result is false, the resource will
   # be kept otherwise it will be skipped
   def filter(&block)
     to_catalog :to_resource, &block
   end
 
   # Store the classes in the classfile.
   def write_class_file
     ::File.open(Puppet[:classfile], "w") do |f|
       f.puts classes.join("\n")
     end
   rescue => detail
     Puppet.err "Could not create class file #{Puppet[:classfile]}: #{detail}"
   end
 
   # Store the list of resources we manage
   def write_resource_file
     ::File.open(Puppet[:resourcefile], "w") do |f|
       to_print = resources.map do |resource|
-        next if resource.type == :component
+        next unless resource.managed?
         "#{resource.type}[#{resource[resource.name_var]}]"
       end.compact
       f.puts to_print.join("\n")
     end
   rescue => detail
     Puppet.err "Could not create resource file #{Puppet[:resourcefile]}: #{detail}"
   end
 
   # Produce the graph files if requested.
   def write_graph(name)
     # We only want to graph the main host catalog.
     return unless host_config?
 
     super
   end
 
   private
 
   # Verify that the given resource isn't defined elsewhere.
   def fail_on_duplicate_type_and_title(resource)
     # Short-curcuit the common case,
     return unless existing_resource = @resource_table[title_key_for_ref(resource.ref)]
 
     # If we've gotten this far, it's a real conflict
     msg = "Duplicate definition: #{resource.ref} is already defined"
 
     msg << " in file #{existing_resource.file} at line #{existing_resource.line}" if existing_resource.file and existing_resource.line
 
     msg << "; cannot redefine" if resource.line or resource.file
 
     raise DuplicateResourceError.new(msg)
   end
 
   # An abstracted method for converting one catalog into another type of catalog.
   # This pretty much just converts all of the resources from one class to another, using
   # a conversion method.
   def to_catalog(convert)
     result = self.class.new(self.name)
 
     result.version = self.version
 
     map = {}
     vertices.each do |resource|
       next if virtual_not_exported?(resource)
       next if block_given? and yield resource
 
       #This is hackity hack for 1094
       #Aliases aren't working in the ral catalog because the current instance of the resource
       #has a reference to the catalog being converted. . . So, give it a reference to the new one
       #problem solved. . .
       if resource.class == Puppet::Resource
         resource = resource.dup
         resource.catalog = result
       elsif resource.is_a?(Puppet::TransObject)
         resource = resource.dup
         resource.catalog = result
       elsif resource.is_a?(Puppet::Parser::Resource)
         resource = resource.to_resource
         resource.catalog = result
       end
 
       if resource.is_a?(Puppet::Resource) and convert.to_s == "to_resource"
         newres = resource
       else
         newres = resource.send(convert)
       end
 
       # We can't guarantee that resources don't munge their names
       # (like files do with trailing slashes), so we have to keep track
       # of what a resource got converted to.
       map[resource.ref] = newres
 
       result.add_resource newres
     end
 
     message = convert.to_s.gsub "_", " "
     edges.each do |edge|
       # Skip edges between virtual resources.
       next if virtual_not_exported?(edge.source)
       next if block_given? and yield edge.source
 
       next if virtual_not_exported?(edge.target)
       next if block_given? and yield edge.target
 
       unless source = map[edge.source.ref]
         raise Puppet::DevError, "Could not find resource #{edge.source.ref} when converting #{message} resources"
       end
 
       unless target = map[edge.target.ref]
         raise Puppet::DevError, "Could not find resource #{edge.target.ref} when converting #{message} resources"
       end
 
       result.add_edge(source, target, edge.label)
     end
 
     map.clear
 
     result.add_class(*self.classes)
     result.tag(*self.tags)
 
     result
   end
 
   def virtual_not_exported?(resource)
     resource.respond_to?(:virtual?) and resource.virtual? and (resource.respond_to?(:exported?) and not resource.exported?)
   end
 end
diff --git a/spec/unit/resource/catalog_spec.rb b/spec/unit/resource/catalog_spec.rb
index cb4df2636..3dbdc3246 100755
--- a/spec/unit/resource/catalog_spec.rb
+++ b/spec/unit/resource/catalog_spec.rb
@@ -1,1121 +1,1131 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Resource::Catalog, "when compiling" do
   include PuppetSpec::Files
 
   before do
     @basepath = make_absolute("/somepath")
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
   end
 
-  it "should write its resources' types, namevars" do
+  # audit only resources are unmanaged
+  # as are resources without properties with should values
+  it "should write its managed resources' types, namevars" do
     catalog = Puppet::Resource::Catalog.new("host")
 
     resourcefile = tmpfile('resourcefile')
     Puppet[:resourcefile] = resourcefile
 
-    res = Puppet::Type.type('file').new(:title => File.expand_path('/tmp/sam'))
+    res = Puppet::Type.type('file').new(:title => File.expand_path('/tmp/sam'), :ensure => 'present')
     res.file = 'site.pp'
     res.line = 21
 
     res2 = Puppet::Type.type('exec').new(:title => 'bob', :command => "#{File.expand_path('/bin/rm')} -rf /")
     res2.file = File.expand_path('/modules/bob/manifests/bob.pp')
     res2.line = 42
 
+    res3 = Puppet::Type.type('file').new(:title => File.expand_path('/tmp/susan'), :audit => 'all')
+    res3.file = 'site.pp'
+    res3.line = 63
+
+    res4 = Puppet::Type.type('file').new(:title => File.expand_path('/tmp/lilly'))
+    res4.file = 'site.pp'
+    res4.line = 84
+
     comp_res = Puppet::Type.type('component').new(:title => 'Class[Main]')
 
-    catalog.add_resource(res, res2, comp_res)
+    catalog.add_resource(res, res2, res3, res4, comp_res)
     catalog.write_resource_file
     File.readlines(resourcefile).map(&:chomp).should =~ [
       "file[#{File.expand_path('/tmp/sam')}]",
       "exec[#{File.expand_path('/bin/rm')} -rf /]"
     ]
   end
 
   it "should log an error if unable to write to the resource file" do
     catalog = Puppet::Resource::Catalog.new("host")
     Puppet[:resourcefile] = File.expand_path('/not/writable/file')
 
     catalog.add_resource(Puppet::Type.type('file').new(:title => File.expand_path('/tmp/foo')))
     catalog.write_resource_file
     @logs.size.should == 1
     @logs.first.message.should =~ /Could not create resource file/
     @logs.first.level.should == :err
   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 transobjects" do
 
     def mkscope
       @node = Puppet::Node.new("mynode")
       @compiler = Puppet::Parser::Compiler.new(@node)
 
       # XXX This is ridiculous.
       @compiler.send(:evaluate_main)
       @scope = @compiler.topscope
     end
 
     def mkresource(type, name)
       Puppet::Parser::Resource.new(type, name, :source => @source, :scope => @scope)
     end
 
     it "should fail if no 'main' stage can be found" do
       lambda { Puppet::Resource::Catalog.new("mynode").extract }.should raise_error(Puppet::DevError)
     end
 
     it "should warn if any non-main stages are present" do
       config = Puppet::Resource::Catalog.new("mynode")
 
       @scope = mkscope
       @source = mock 'source'
 
       main = mkresource("stage", "main")
       config.add_resource(main)
 
       other = mkresource("stage", "other")
       config.add_resource(other)
 
       Puppet.expects(:warning)
 
       config.extract
     end
 
     it "should always create a TransBucket for the 'main' stage" do
       config = Puppet::Resource::Catalog.new("mynode")
 
       @scope = mkscope
       @source = mock 'source'
 
       main = mkresource("stage", "main")
       config.add_resource(main)
 
       result = config.extract
       result.type.should == "Stage"
       result.name.should == "main"
     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 "stage", "main"
 
       config.add_resource top
       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
 
       # 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 convert parser resources to plain resources" do
       resource = Puppet::Parser::Resource.new(:file, "foo", :scope => stub("scope", :environment => nil, :namespaces => nil), :source => stub("source"))
       catalog = Puppet::Resource::Catalog.new("whev")
       catalog.add_resource(resource)
       new = catalog.to_resource
       new.resource(:file, "foo").class.should == Puppet::Resource
     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, @basepath+'/topobject'
       @middle         = Puppet::Resource.new :class, 'middle'
       @middleobject   = Puppet::Resource.new :file, @basepath+'/middleobject'
       @bottom         = Puppet::Resource.new :class, 'bottom'
       @bottomobject   = Puppet::Resource.new :file, @basepath+'/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_not be
     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 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 isomorphic resources whose names do not match their titles" do
       resource = Puppet::Type::File.new(:title => "testing", :path => @basepath+"/something")
 
       @catalog.add_resource(resource)
 
       @catalog.resource(:file, @basepath+"/something").should equal(resource)
     end
 
     it "should not create aliases for non-isomorphic resources whose names do not match their titles", :fails_on_windows => true  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 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 => @basepath+"/something", :title => "other", :content => "blah"
       resource.expects(:isomorphic?).returns(true)
       @catalog.add_resource(resource)
       @catalog.resource(:file, "other").should equal(resource)
       @catalog.resource(:file, @basepath+"/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 => @basepath+"/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.
       raise "Aliased non-isomorphic resource" if @catalog.resource(:file, resource.name)
     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
 
     describe "when adding resources with multiple namevars" do
       before :each do
         Puppet::Type.newtype(:multiple) do
           newparam(:color, :namevar => true)
           newparam(:designation, :namevar => true)
 
           def self.title_patterns
             [ [
                 /^(\w+) (\w+)$/,
                 [
                   [:color,  lambda{|x| x}],
                   [:designation, lambda{|x| x}]
                 ]
             ] ]
           end
         end
       end
 
       it "should add an alias using the uniqueness key" do
         @resource = Puppet::Type.type(:multiple).new(:title => "some resource", :color => "red", :designation => "5")
 
         @catalog.add_resource(@resource)
         @catalog.resource(:multiple, "some resource").must == @resource
         @catalog.resource("Multiple[some resource]").must == @resource
         @catalog.resource("Multiple[red 5]").must == @resource
       end
 
       it "should conflict with a resource with the same uniqueness key" do
         @resource = Puppet::Type.type(:multiple).new(:title => "some resource", :color => "red", :designation => "5")
         @other    = Puppet::Type.type(:multiple).new(:title => "another resource", :color => "red", :designation => "5")
 
         @catalog.add_resource(@resource)
         expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias Multiple\[another resource\] to \["red", "5"\].*resource \["Multiple", "red", "5"\] already defined/)
       end
 
       it "should conflict when its uniqueness key matches another resource's title" do
         path = make_absolute("/tmp/foo")
         @resource = Puppet::Type.type(:file).new(:title => path)
         @other    = Puppet::Type.type(:file).new(:title => "another file", :path => path)
 
         @catalog.add_resource(@resource)
         expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias File\[another file\] to \["#{Regexp.escape(path)}"\].*resource \["File", "#{Regexp.escape(path)}"\] already defined/)
       end
 
       it "should conflict when its uniqueness key matches the uniqueness key derived from another resource's title" do
         @resource = Puppet::Type.type(:multiple).new(:title => "red leader")
         @other    = Puppet::Type.type(:multiple).new(:title => "another resource", :color => "red", :designation => "leader")
 
         @catalog.add_resource(@resource)
         expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias Multiple\[another resource\] to \["red", "leader"\].*resource \["Multiple", "red", "leader"\] already defined/)
       end
     end
   end
 
   describe "when applying" do
     before :each do
       @catalog = Puppet::Resource::Catalog.new("host")
 
       @transaction = Puppet::Transaction.new(@catalog)
       Puppet::Transaction.stubs(:new).returns(@transaction)
       @transaction.stubs(:evaluate)
       @transaction.stubs(:add_times)
       @transaction.stubs(:for_network_device=)
 
       Puppet.settings.stubs(:use)
     end
 
     it "should create and evaluate a transaction" do
       @transaction.expects(:evaluate)
       @catalog.apply
     end
 
     it "should provide the catalog retrieval time to the transaction" do
       @catalog.retrieval_duration = 5
       @transaction.expects(:add_times).with(:config_retrieval => 5)
       @catalog.apply
     end
 
     it "should use a retrieval time of 0 if none is set in the catalog" do
       @catalog.retrieval_duration = nil
       @transaction.expects(:add_times).with(:config_retrieval => 0)
       @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 being a host catalog" do
       @catalog.host_config.should be_true
     end
 
     it "should be able to be set to a non-host_config" do
       @catalog.host_config = false
       @catalog.host_config.should be_false
     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
 
     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 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
         @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 => @basepath+"/one"
       @two = @file.new :path => @basepath+"/two"
       @sub = @file.new :path => @basepath+"/two/subdir"
       @catalog.add_edge @compone, @one
       @catalog.add_edge @comptwo, @two
 
       @three = @file.new :path => @basepath+"/three"
       @four = @file.new :path => @basepath+"/four", :require => "File[#{@basepath}/three]"
       @five = @file.new :path => @basepath+"/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.path_between(@one, @two).should be
     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
     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
       @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", :if => Puppet.features.pson? do
   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.edges_between(one, two  )[0].expects(:to_pson_data_hash).returns "one_two_pson"
     @catalog.edges_between(two, three)[0].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", :if => Puppet.features.pson? do
   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.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
 
   describe "#title_key_for_ref" do
     it "should parse a resource ref string into a pair" do
       @catalog.title_key_for_ref("Title[name]").should == ["Title", "name"]
     end
     it "should parse a resource ref string into a pair, even if there's a newline inside the name" do
       @catalog.title_key_for_ref("Title[na\nme]").should == ["Title", "na\nme"]
     end
   end
 end
diff --git a/spec/unit/type_spec.rb b/spec/unit/type_spec.rb
index db025842c..4903f8457 100755
--- a/spec/unit/type_spec.rb
+++ b/spec/unit/type_spec.rb
@@ -1,644 +1,662 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Type, :fails_on_windows => true do
   include PuppetSpec::Files
 
   it "should consider a parameter to be valid if it is a valid parameter" do
     Puppet::Type.type(:mount).should be_valid_parameter(:path)
   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 "should have a method for setting default values for resources" do
     Puppet::Type.type(:mount).new(:name => "foo").should 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").should 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").should respond_to(:exported?)
   end
 
   it "should have a method to know if the resource is virtual" do
     Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:virtual?)
   end
 
   it "should consider its version to be its catalog version" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     catalog = Puppet::Resource::Catalog.new
     catalog.version = 50
     catalog.add_resource resource
 
     resource.version.should == 50
   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
 
   it "should provide source_descriptors" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     catalog = Puppet::Resource::Catalog.new
     catalog.version = 50
     catalog.add_resource resource
 
     resource.source_descriptors.should == {:tags=>["mount", "foo"], :path=>"/Mount[foo]"}
   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)
+      @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 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 TransObject" do
       it "should fail" do
         trans = Puppet::TransObject.new("/foo", :mount)
         lambda { Puppet::Type.type(:mount).new(trans) }.should raise_error(Puppet::DevError)
       end
     end
 
     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 => true, :fstype => "boo"})
         params = Puppet::Type.type(:mount).new(resource).to_hash
         params[:fstype].should == "boo"
         params[:atboot].should == true
       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 => true, :fstype => "boo")
         resource[:fstype].must == "boo"
         resource[:atboot].must == true
       end
     end
 
     it "should fail if any invalid attributes have been provided" do
       lambda { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.should raise_error(Puppet::Error)
     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
       lambda { Puppet::Type.type(:file).new(:atboot => true) }.should 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 => "myboot", :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 => "myboot"})
 
       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 => true, :noop => false).original_parameters.should == {:atboot => true, :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
   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
       lambda { @resource.retrieve_resource }.should 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] = "my name"
       @resource.title = "other name"
       @resource.retrieve_resource[:name].should == "my name"
     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 ".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
 end
 
 describe Puppet::Type::RelationshipMetaparam, :fails_on_windows => true 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", :'fails_on_windows' => true do
     before do
       @path = make_absolute('/foo')
       @resource = Puppet::Type.type(:mount).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
 
   it "should fail if any specified resource is not found in the catalog" do
     catalog = mock 'catalog'
     resource = stub 'resource', :catalog => catalog, :ref => "resource"
 
     param = Puppet::Type.metaparamclass(:require).new(:resource => resource, :value => %w{Foo[bar] Class[test]})
 
     catalog.expects(:resource).with("Foo[bar]").returns "something"
     catalog.expects(:resource).with("Class[Test]").returns nil
 
     param.expects(:fail).with { |string| string.include?("Class[Test]") }
 
     param.validate_relationship
   end
 end
 
 describe Puppet::Type.metaparamclass(:check), :fails_on_windows => true do
   include PuppetSpec::Files
 
   it "should warn and create an instance of ':audit'" do
     file = Puppet::Type.type(:file).new :path => make_absolute('/foo')
     file.expects(:warning)
     file[:check] = :mode
     file[:audit].should == [:mode]
   end
 end
 
 describe Puppet::Type.metaparamclass(:audit), :fails_on_windows => true 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
     lambda { @resource[:audit] = :foobar }.should 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
 end