diff --git a/lib/puppet/pgraph.rb b/lib/puppet/pgraph.rb
index a8ff952ed..e7247418c 100644
--- a/lib/puppet/pgraph.rb
+++ b/lib/puppet/pgraph.rb
@@ -1,122 +1,127 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke A. Kanies on 2006-11-24.
 #  Copyright (c) 2006. All rights reserved.
 
 require 'puppet/gratr/digraph'
 require 'puppet/gratr/import'
 require 'puppet/gratr/dot'
 require 'puppet/relationship'
 
 # This class subclasses a graph class in order to handle relationships
 # among resources.
 class Puppet::PGraph < GRATR::Digraph
     # This is the type used for splicing.
     attr_accessor :container_type
     
     def clear
         @vertex_dict.clear
         if defined? @edge_number
             @edge_number.clear
         end
     end
+
+    # Which resources a given resource depends upon.
+    def dependents(resource)
+        tree_from_vertex(resource, :dfs).keys
+    end
     
-    # The dependencies for a given resource.
+    # The which resources depend upon the given resource.
     def dependencies(resource)
-        tree_from_vertex(resource, :dfs).keys
+        reversal.tree_from_vertex(resource, :dfs).keys
     end
     
     # Override this method to use our class instead.
     def edge_class()
         Puppet::Relationship
     end
     
     # Determine all of the leaf nodes below a given vertex.
     def leaves(vertex, type = :dfs)
         tree = tree_from_vertex(vertex, type)
         leaves = tree.keys.find_all { |c| adjacent(c, :direction => :out).empty? }
         return leaves
     end
     
     # Collect all of the edges that the passed events match.  Returns
     # an array of edges.
     def matching_edges(events)
         events.collect do |event|
             source = event.source
             
             unless vertex?(source)
                 Puppet.warning "Got an event from invalid vertex %s" % source.ref
                 next
             end
             
             # Get all of the edges that this vertex should forward events
             # to, which is the same thing as saying all edges directly below
             # This vertex in the graph.
             adjacent(source, :direction => :out, :type => :edges).find_all do |edge|
                 edge.match?(event.event)
             end.each { |edge|
                 target = edge.target
                 if target.respond_to?(:ref)
                     source.info "Scheduling %s of %s" %
                         [edge.callback, target.ref]
                 end
             }
         end.flatten
     end
     
     # Take container information from another graph and use it
     # to replace any container vertices with their respective leaves.
     # This creates direct relationships where there were previously
     # indirect relationships through the containers. 
     def splice!(other, type)
         vertices.each do |vertex|
             # Go through each vertex and replace the edges with edges
             # to the leaves instead
             next unless vertex.is_a?(type)
             
             leaves = other.leaves(vertex)
             if leaves.empty?
                 remove_vertex!(vertex)
                 next
             end
             
             # First create new edges for each of the :in edges
             adjacent(vertex, :direction => :in, :type => :edges).each do |edge|
                 leaves.each do |leaf|
                     add_edge!(edge.source, leaf, edge.label)
                     if cyclic?
                         raise ArgumentError,
                             "%s => %s results in a loop" %
                             [up, leaf]
                     end
                 end
             end
             
             # Then for each of the out edges
             adjacent(vertex, :direction => :out, :type => :edges).each do |edge|
                 leaves.each do |leaf|
                     add_edge!(leaf, edge.target, edge.label)
                     if cyclic?
                         raise ArgumentError,
                             "%s => %s results in a loop" %
                             [leaf, down]
                     end
                 end
             end
             
             # And finally, remove the vertex entirely.
             remove_vertex!(vertex)
         end
     end
     
     # For some reason, unconnected vertices do not show up in
     # this graph.
     def to_jpg(path, name)
         gv = vertices()
         Dir.chdir(path) do
             induced_subgraph(gv).write_to_graphic_file('jpg', name)
         end
     end
 end
 
 # $Id$
diff --git a/lib/puppet/transaction.rb b/lib/puppet/transaction.rb
index 99b03b435..67d016c15 100644
--- a/lib/puppet/transaction.rb
+++ b/lib/puppet/transaction.rb
@@ -1,592 +1,602 @@
 # the class that actually walks our resource/state tree, collects the changes,
 # and performs them
 
 require 'puppet'
 require 'puppet/statechange'
 
 module Puppet
 class Transaction
     attr_accessor :component, :resources, :ignoreschedules, :ignoretags
     attr_accessor :relgraph, :sorted_resources
     
     attr_writer :tags
 
     include Puppet::Util
 
     Puppet.config.setdefaults(:transaction,
         :tags => ["", "Tags to use to find resources.  If this is set, then
             only resources tagged with the specified tags will be applied.
             Values must be comma-separated."]
     )
 
     # Add some additional times for reporting
     def addtimes(hash)
         hash.each do |name, num|
             @timemetrics[name] = num
         end
     end
 
     # Apply all changes for a resource, returning a list of the events
     # generated.
     def apply(resource)
         begin
             changes = resource.evaluate
         rescue => detail
             if Puppet[:trace]
                 puts detail.backtrace
             end
 
             resource.err "Failed to retrieve current state: %s" % detail
 
             # Mark that it failed
             @failures[resource] += 1
 
             # And then return
             return []
         end
+        
+        # If a resource is going to be deleted but it still has dependencies, then
+        # don't delete it unless it's implicit.
+        if ! resource.implicit? and deps = @relgraph.dependents(resource) and ! deps.empty? and changes.detect { |change|
+            change.state.name == :ensure and change.should == :absent
+        }
+            resource.warning "%s still depend%s on me -- not deleting" %
+                [deps.collect { |r| r.ref }.join(","), if deps.length > 1; ""; else "s"; end] 
+            return []
+        end
 
         unless changes.is_a? Array
             changes = [changes]
         end
 
         if changes.length > 0
             @resourcemetrics[:out_of_sync] += 1
         end
 
         resourceevents = changes.collect { |change|
             @changes << change
             @count += 1
             change.transaction = self
             events = nil
             begin
                 # use an array, so that changes can return more than one
                 # event if they want
                 events = [change.forward].flatten.reject { |e| e.nil? }
             rescue => detail
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
                 change.state.err "change from %s to %s failed: %s" %
                     [change.state.is_to_s, change.state.should_to_s, detail]
                 @failures[resource] += 1
                 next
                 # FIXME this should support using onerror to determine
                 # behaviour; or more likely, the client calling us
                 # should do so
             end
 
             # Mark that our change happened, so it can be reversed
             # if we ever get to that point
             unless events.nil? or (events.is_a?(Array) and events.empty?)
                 change.changed = true
                 @resourcemetrics[:applied] += 1
             end
 
             events
         }.flatten.reject { |e| e.nil? }
 
         unless changes.empty?
             # Record when we last synced
             resource.cache(:synced, Time.now)
 
             # Flush, if appropriate
             if resource.respond_to?(:flush)
                 resource.flush
             end
         end
 
         resourceevents
     end
 
     # Find all of the changed resources.
     def changed?
         @changes.find_all { |change| change.changed }.collect { |change|
             change.state.parent
         }.uniq
     end
     
     # Do any necessary cleanup.  If we don't get rid of the graphs, the
     # contained resources might never get cleaned up.
     def cleanup
         @generated.each do |resource|
             resource.remove
         end
         if defined? @relgraph
             @relgraph.clear
         end
         @resources.clear
     end
     
     # See if the resource generates new resources at evaluation time.
     def eval_generate(resource)
         if resource.respond_to?(:eval_generate)
             if children = resource.eval_generate
                 depthfirst = resource.depthfirst?
                 dependents = @relgraph.adjacent(resource, :direction => :out, :type => :edges)
                 targets = @relgraph.adjacent(resource, :direction => :in, :type => :edges)
                 children.each do |gen_child|
                     if depthfirst
                         @relgraph.add_edge!(gen_child, resource)
                     else
                         @relgraph.add_edge!(resource, gen_child)
                     end
                     dependents.each do |edge|
                         @relgraph.add_edge!(gen_child, edge.target, edge.label)
                     end
                     targets.each do |edge|
                         @relgraph.add_edge!(edge.source, gen_child, edge.label)
                     end
                     @generated << gen_child
                 end
                 return children
             end
         end
     end
     
     # Evaluate a single resource.
     def eval_resource(resource)
         events = []
         
         if resource.is_a?(Puppet::Type::Component)
             raise Puppet::DevError, "Got a component to evaluate"
         end
         
         if skip?(resource)
             @resourcemetrics[:skipped] += 1
         else
             @resourcemetrics[:scheduled] += 1
             
             # We need to generate first regardless, because the recursive
             # actions sometimes change how the top resource is applied.
             children = eval_generate(resource)
             
             if resource.depthfirst? and children
                 children.each do |child|
                     events += eval_resource(child)
                 end
             end
 
             # Perform the actual changes
             seconds = thinmark do
                 events += apply(resource)
             end
             
             if ! resource.depthfirst? and children
                 children.each do |child|
                     events += eval_resource(child)
                 end
             end
 
             # Keep track of how long we spend in each type of resource
             @timemetrics[resource.class.name] += seconds
         end
 
         # Check to see if there are any events for this resource
         if triggedevents = trigger(resource)
             events += triggedevents
         end
 
         # Collect the targets of any subscriptions to those events
         @relgraph.matching_edges(events).each do |edge|
             @targets[edge.target] << edge
         end
 
         # And return the events for collection
         events
     end
 
     # This method does all the actual work of running a transaction.  It
     # collects all of the changes, executes them, and responds to any
     # necessary events.
     def evaluate
         @count = 0
         
         # Start logging.
         Puppet::Log.newdestination(@report)
         
         prepare()
 
         begin
             allevents = @sorted_resources.collect { |resource|
                 eval_resource(resource)
             }.flatten.reject { |e| e.nil? }
         ensure
             # And then close the transaction log.
             Puppet::Log.close(@report)
         end
 
         Puppet.debug "Finishing transaction %s with %s changes" %
             [self.object_id, @count]
 
         allevents
     end
 
     # Determine whether a given resource has failed.
     def failed?(obj)
         if @failures[obj] > 0
             return @failures[obj]
         else
             return false
         end
     end
 
     # Does this resource have any failed dependencies?
     def failed_dependencies?(resource)
         # First make sure there are no failed dependencies.  To do this,
         # we check for failures in any of the vertexes above us.  It's not
         # enough to check the immediate dependencies, which is why we use
         # a tree from the reversed graph.
         skip = false
-        @relgraph.reversal.tree_from_vertex(resource, :dfs).keys.each do |dep|
+        @relgraph.dependencies(resource).each do |dep|
             if fails = failed?(dep)
                 resource.notice "Dependency %s[%s] has %s failures" %
                     [dep.class.name, dep.name, @failures[dep]]
                 skip = true
             end
         end
         
         return skip
     end
     
     # Collect any dynamically generated resources.
     def generate
         list = @resources.vertices
         
         # Store a list of all generated resources, so that we can clean them up
         # after the transaction closes.
         @generated = []
         
         newlist = []
         while ! list.empty?
             list.each do |resource|
                 if resource.respond_to?(:generate)
                     made = resource.generate
                     next unless made
                     unless made.is_a?(Array)
                         made = [made]
                     end
                     made.uniq!
                     made.each do |res|
                         @resources.add_vertex!(res)
                         newlist << res
                         @generated << res
                     end
                 end
             end
             list.clear
             list = newlist
             newlist = []
         end
     end
 
     # this should only be called by a Puppet::Type::Component resource now
     # and it should only receive an array
     def initialize(resources)
         @resources = resources.to_graph
 
         @resourcemetrics = {
             :total => @resources.vertices.length,
             :out_of_sync => 0,    # The number of resources that had changes
             :applied => 0,        # The number of resources fixed
             :skipped => 0,      # The number of resources skipped
             :restarted => 0,    # The number of resources triggered
             :failed_restarts => 0, # The number of resources that fail a trigger
             :scheduled => 0     # The number of resources scheduled
         }
 
         # Metrics for distributing times across the different types.
         @timemetrics = Hash.new(0)
 
         # The number of resources that were triggered in this run
         @triggered = Hash.new { |hash, key|
             hash[key] = Hash.new(0)
         }
 
         # Targets of being triggered.
         @targets = Hash.new do |hash, key|
             hash[key] = []
         end
 
         # The changes we're performing
         @changes = []
 
         # The resources that have failed and the number of failures each.  This
         # is used for skipping resources because of failed dependencies.
         @failures = Hash.new do |h, key|
             h[key] = 0
         end
 
         @report = Report.new
     end
 
     # Prefetch any providers that support it.  We don't support prefetching
     # types, just providers.
     def prefetch
         @resources.collect { |obj|
             if pro = obj.provider
                 pro.class
             else
                 nil
             end
         }.reject { |o| o.nil? }.uniq.each do |klass|
             # XXX We need to do something special here in case of failure.
             if klass.respond_to?(:prefetch)
                 klass.prefetch
             end
         end
     end
     
     # Prepare to evaluate the elements in a transaction.
     def prepare
         prefetch()
     
         # Now add any dynamically generated resources
         generate()
     
         # Create a relationship graph from our resource graph
         @relgraph = relationship_graph
         
         @sorted_resources = @relgraph.topsort
     end
     
     # Create a graph of all of the relationships in our resource graph.
     def relationship_graph
         graph = Puppet::PGraph.new
         
         # First create the dependency graph
         @resources.vertices.each do |vertex|
             graph.add_vertex!(vertex)
             vertex.builddepends.each do |edge|
                 graph.add_edge!(edge)
             end
         end
         
         # Then splice in the container information
         graph.splice!(@resources, Puppet::Type::Component)
         
         # Lastly, add in any autorequires
         graph.vertices.each do |vertex|
             vertex.autorequire.each do |edge|
                 unless graph.edge?(edge)
                     graph.add_edge!(edge)
                 end
             end
         end
         
         return graph
     end
 
     # Generate a transaction report.
     def report
         @resourcemetrics[:failed] = @failures.find_all do |name, num|
             num > 0
         end.length
 
         # Get the total time spent
         @timemetrics[:total] = @timemetrics.inject(0) do |total, vals|
             total += vals[1]
             total
         end
 
         # Unfortunately, RRD does not deal well with changing lists of values,
         # so we have to pick a list of values and stick with it.  In this case,
         # that means we record the total time, the config time, and that's about
         # it.  We should probably send each type's time as a separate metric.
         @timemetrics.dup.each do |name, value|
             if Puppet::Type.type(name)
                 @timemetrics.delete(name)
             end
         end
 
         # Add all of the metrics related to resource count and status
         @report.newmetric(:resources, @resourcemetrics)
 
         # Record the relative time spent in each resource.
         @report.newmetric(:time, @timemetrics)
 
         # Then all of the change-related metrics
         @report.newmetric(:changes,
             :total => @changes.length
         )
 
         @report.time = Time.now
 
         return @report
     end
 
     # Roll all completed changes back.
     def rollback
         @targets.clear
         @triggered.clear
         allevents = @changes.reverse.collect { |change|
             # skip changes that were never actually run
             unless change.changed
                 Puppet.debug "%s was not changed" % change.to_s
                 next
             end
             begin
                 events = change.backward
             rescue => detail
                 Puppet.err("%s rollback failed: %s" % [change,detail])
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
                 next
                 # at this point, we would normally do error handling
                 # but i haven't decided what to do for that yet
                 # so just record that a sync failed for a given resource
                 #@@failures[change.state.parent] += 1
                 # this still could get hairy; what if file contents changed,
                 # but a chmod failed?  how would i handle that error? dern
             end
             
             @relgraph.matching_edges(events).each do |edge|
                 @targets[edge.target] << edge
             end
 
             # Now check to see if there are any events for this child.
             # Kind of hackish, since going backwards goes a change at a
             # time, not a child at a time.
             trigger(change.state.parent)
 
             # And return the events for collection
             events
         }.flatten.reject { |e| e.nil? }
     end
     
     # Is the resource currently scheduled?
     def scheduled?(resource)
         self.ignoreschedules or resource.scheduled?
     end
     
     # Should this resource be skipped?
     def skip?(resource)
         skip = false
         if ! tagged?(resource)
             resource.debug "Not tagged with %s" % tags.join(", ")
         elsif ! scheduled?(resource)
             resource.debug "Not scheduled"
         elsif failed_dependencies?(resource)
             resource.warning "Skipping because of failed dependencies"
         else
             return false
         end
         return true
     end
     
     # The tags we should be checking.
     def tags
         # Allow the tags to be overridden
         unless defined? @tags
             @tags = Puppet[:tags]
         end
         
         unless defined? @processed_tags
             if @tags.nil? or @tags == ""
                 @tags = []
             else
                 @tags = [@tags] unless @tags.is_a? Array
                 @tags = @tags.collect do |tag|
                     tag.split(/\s*,\s*/)
                 end.flatten
             end
             @processed_tags = true
         end
         
         @tags
     end
     
     # Is this resource tagged appropriately?
     def tagged?(resource)
         self.ignoretags or tags.empty? or resource.tagged?(tags)
     end
     
     # Are there any edges that target this resource?
     def targeted?(resource)
         @targets[resource]
     end
 
     # Trigger any subscriptions to a child.  This does an upwardly recursive
     # search -- it triggers the passed resource, but also the resource's parent
     # and so on up the tree.
     def trigger(child)
         obj = child
         callbacks = Hash.new { |hash, key| hash[key] = [] }
         sources = Hash.new { |hash, key| hash[key] = [] }
 
         trigged = []
         while obj
             if @targets.include?(obj)
                 callbacks.clear
                 sources.clear
                 @targets[obj].each do |edge|
                     # Some edges don't have callbacks
                     next unless edge.callback
                     
                     # Collect all of the subs for each callback
                     callbacks[edge.callback] << edge
 
                     # And collect the sources for logging
                     sources[edge.source] << edge.callback
                 end
 
                 sources.each do |source, callbacklist|
                     obj.debug "%s[%s] results in triggering %s" %
                         [source.class.name, source.name, callbacklist.join(", ")]
                 end
 
                 callbacks.each do |callback, subs|
                     message = "Triggering '%s' from %s dependencies" %
                         [callback, subs.length]
                     obj.notice message
                     # At this point, just log failures, don't try to react
                     # to them in any way.
                     begin
                         obj.send(callback)
                         @resourcemetrics[:restarted] += 1
                     rescue => detail
                         obj.err "Failed to call %s on %s: %s" %
                             [callback, obj, detail]
 
                         @resourcemetrics[:failed_restarts] += 1
 
                         if Puppet[:trace]
                             puts detail.backtrace
                         end
                     end
 
                     # And then add an event for it.
                     trigged << Puppet::Event.new(
                         :event => :triggered,
                         :transaction => self,
                         :source => obj,
                         :message => message
                     )
 
                     triggered(obj, callback)
                 end
             end
 
             obj = obj.parent
         end
 
         if trigged.empty?
             return nil
         else
             return trigged
         end
     end
 
     def triggered(resource, method)
         @triggered[resource][method] += 1
     end
 
     def triggered?(resource, method)
         @triggered[resource][method]
     end
 end
 end
 
 require 'puppet/transaction/report'
 
 # $Id$
diff --git a/lib/puppet/type.rb b/lib/puppet/type.rb
index 2c99e3343..e55f9f5ae 100644
--- a/lib/puppet/type.rb
+++ b/lib/puppet/type.rb
@@ -1,405 +1,405 @@
 require 'puppet'
 require 'puppet/log'
 require 'puppet/element'
 require 'puppet/event'
 require 'puppet/metric'
 require 'puppet/type/state'
 require 'puppet/parameter'
 require 'puppet/util'
 require 'puppet/autoload'
 require 'puppet/metatype/manager'
 
 # see the bottom of the file for the rest of the inclusions
 
 module Puppet
 class Type < Puppet::Element
     # Nearly all of the code in this class is stored in files in the
     # metatype/ directory.  This is a temporary measure until I get a chance
     # to refactor this class entirely.  There's still more simplification to
     # do, but this works for now.
     require 'puppet/metatype/attributes'
     require 'puppet/metatype/closure'
     require 'puppet/metatype/container'
     require 'puppet/metatype/evaluation'
     require 'puppet/metatype/instances'
     require 'puppet/metatype/metaparams'
     require 'puppet/metatype/providers'
     require 'puppet/metatype/relationships'
     require 'puppet/metatype/schedules'
     require 'puppet/metatype/tags'
 
     # Types (which map to elements in the languages) are entirely composed of
     # attribute value pairs.  Generally, Puppet calls any of these things an
     # 'attribute', but these attributes always take one of three specific
     # forms:  parameters, metaparams, or states.
 
     # In naming methods, I have tried to consistently name the method so
     # that it is clear whether it operates on all attributes (thus has 'attr' in
     # the method name, or whether it operates on a specific type of attributes.
     attr_accessor :file, :line
     attr_reader :parent
 
     attr_writer :title
 
     include Enumerable
     
     # class methods dealing with Type management
 
     public
 
     # the Type class attribute accessors
     class << self
         attr_reader :name
         include Enumerable, Puppet::Util::ClassGen
         include Puppet::MetaType::Manager
     end
 
     # all of the variables that must be initialized for each subclass
     def self.initvars
         # all of the instances of this class
         @objects = Hash.new
         @aliases = Hash.new
 
         @providers = Hash.new
         @defaults = {}
 
         unless defined? @parameters
             @parameters = []
         end
 
         @validstates = {}
         @states = []
         @parameters = []
         @paramhash = {}
 
         @paramdoc = Hash.new { |hash,key|
           if key.is_a?(String)
             key = key.intern
           end
           if hash.include?(key)
             hash[key]
           else
             "Param Documentation for %s not found" % key
           end
         }
 
         unless defined? @doc
             @doc = ""
         end
 
         unless defined? @states
             @states = []
         end
 
     end
 
     def self.to_s
         if defined? @name
             "Puppet::Type::" + @name.to_s.capitalize
         else
             super
         end
     end
 
     # Create a block to validate that our object is set up entirely.  This will
     # be run before the object is operated on.
     def self.validate(&block)
         define_method(:validate, &block)
         #@validate = block
     end
 
     # iterate across all children, and then iterate across states
     # we do children first so we're sure that all dependent objects
     # are checked first
     # we ignore parameters here, because they only modify how work gets
     # done, they don't ever actually result in work specifically
     def each
         # we want to return the states in the order that each type
         # specifies it, because it may (as in the case of File#create)
         # be important
         if self.class.depthfirst?
             @children.each { |child|
                 yield child
             }
         end
         self.eachstate { |state|
             yield state
         }
         unless self.class.depthfirst?
             @children.each { |child|
                 yield child
             }
         end
     end
 
     # Recurse deeply through the tree, but only yield types, not states.
     def delve(&block)
         self.each do |obj|
             if obj.is_a? Puppet::Type
                 obj.delve(&block)
             end
         end
         block.call(self)
     end
     
     # create a log at specified level
     def log(msg)
         Puppet::Log.create(
             :level => @metaparams[:loglevel].value,
             :message => msg,
             :source => self
         )
     end
 
 
     # instance methods related to instance intrinsics
     # e.g., initialize() and name()
 
     public
 
     def initvars
         @children = []
         @evalcount = 0
         @tags = []
 
         # callbacks are per object and event
         @callbacks = Hash.new { |chash, key|
             chash[key] = {}
         }
 
         # states and parameters are treated equivalently from the outside:
         # as name-value pairs (using [] and []=)
         # internally, however, parameters are merely a hash, while states
         # point to State objects
         # further, the lists of valid states and parameters are defined
         # at the class level
         unless defined? @states
             @states = Hash.new(false)
         end
         unless defined? @parameters
             @parameters = Hash.new(false)
         end
         unless defined? @metaparams
             @metaparams = Hash.new(false)
         end
 
         # set defalts
         @noop = false
         # keeping stats for the total number of changes, and how many were
         # completely sync'ed
         # this isn't really sufficient either, because it adds lots of special
         # cases such as failed changes
         # it also doesn't distinguish between changes from the current transaction
         # vs. changes over the process lifetime
         @totalchanges = 0
         @syncedchanges = 0
         @failedchanges = 0
 
         @inited = true
     end
 
     # initialize the type instance
     def initialize(hash)
         unless defined? @inited
             self.initvars
         end
         namevar = self.class.namevar
 
         orighash = hash
 
         # If we got passed a transportable object, we just pull a bunch of info
         # directly from it.  This is the main object instantiation mechanism.
         if hash.is_a?(Puppet::TransObject)
             #self[:name] = hash[:name]
             [:file, :line, :tags].each { |getter|
                 if hash.respond_to?(getter)
                     setter = getter.to_s + "="
                     if val = hash.send(getter)
                         self.send(setter, val)
                     end
                 end
             }
 
             # XXX This will need to change when transobjects change to titles.
             @title = hash.name
             hash = hash.to_hash
         elsif hash[:title]
             # XXX This should never happen
             @title = hash[:title]
             hash.delete(:title)
         end
 
         # Before anything else, set our parent if it was included
         if hash.include?(:parent)
             @parent = hash[:parent]
             hash.delete(:parent)
         end
 
         # Munge up the namevar stuff so we only have one value.
         hash = self.argclean(hash)
 
         # Let's do the name first, because some things need to happen once
         # we have the name but before anything else
 
         attrs = self.class.allattrs
 
         if hash.include?(namevar)
             #self.send(namevar.to_s + "=", hash[namevar])
             self[namevar] = hash[namevar]
             hash.delete(namevar)
             if attrs.include?(namevar)
                 attrs.delete(namevar)
             else
                 self.devfail "My namevar isn\'t a valid attribute...?"
             end
         else
             self.devfail "I was not passed a namevar"
         end
 
         # If the name and title differ, set up an alias
         if self.name != self.title
             if obj = self.class[self.name] 
                 if self.class.isomorphic?
                     raise Puppet::Error, "%s already exists with name %s" %
                         [obj.title, self.name]
                 end
             else
                 self.class.alias(self.name, self)
             end
         end
 
         # This is all of our attributes except the namevar.
         attrs.each { |attr|
             if hash.include?(attr)
                 begin
                     self[attr] = hash[attr]
                 rescue ArgumentError, Puppet::Error, TypeError
                     raise
                 rescue => detail
                     self.devfail(
                         "Could not set %s on %s: %s" %
                             [attr, self.class.name, detail]
                     )
                 end
                 hash.delete attr
             end
         }
         
         # Set all default values.
         self.setdefaults
 
         if hash.length > 0
             self.debug hash.inspect
             self.fail("Class %s does not accept argument(s) %s" %
                 [self.class.name, hash.keys.join(" ")])
         end
 
         if self.respond_to?(:validate)
             self.validate
         end
     end
 
     # Set up all of our autorequires.
     def finish
         # Scheduling has to be done when the whole config is instantiated, so
         # that file order doesn't matter in finding them.
         self.schedule
     end
 
     # Return a cached value
     def cached(name)
         Puppet::Storage.cache(self)[name]
         #@cache[name] ||= nil
     end
 
     # Cache a value
     def cache(name, value)
         Puppet::Storage.cache(self)[name] = value
         #@cache[name] = value
     end
 
 #    def set(name, value)
 #        send(name.to_s + "=", value)
 #    end
 #
 #    def get(name)
 #        send(name)
 #    end
 
     # For now, leave the 'name' method functioning like it used to.  Once 'title'
     # works everywhere, I'll switch it.
     def name
         return self[:name]
     end
 
     # Return the "type[name]" style reference.
     def ref
-        "%s[%s]" % [self.class.name, self.title]
+        "%s[%s]" % [self.class.name.to_s.capitalize, self.title]
     end
 
     # Retrieve the title of an object.  If no title was set separately,
     # then use the object's name.
     def title
         unless defined? @title and @title
             namevar = self.class.namevar
             if self.class.validparameter?(namevar)
                 @title = self[:name]
             elsif self.class.validstate?(namevar)
                 @title = self.should(namevar)
             else
                 self.devfail "Could not find namevar %s for %s" %
                     [namevar, self.class.name]
             end
         end
 
         return @title
     end
 
     # convert to a string
     def to_s
         self.title
     end
 
     # Convert to a transportable object
     def to_trans(ret = true)
         # Retrieve the object, if they tell use to.
         if ret
             retrieve()
         end
 
         trans = TransObject.new(self.title, self.class.name)
 
         states().each do |state|
             trans[state.name] = state.is
         end
 
         @parameters.each do |name, param|
             # Avoid adding each instance name as both the name and the namevar
             next if param.class.isnamevar? and param.value == self.title
             trans[name] = param.value
         end
 
         @metaparams.each do |name, param|
             trans[name] = param.value
         end
 
         trans.tags = self.tags
 
         # FIXME I'm currently ignoring 'parent' and 'path'
 
         return trans
     end
 
 end # Puppet::Type
 end
 
 require 'puppet/statechange'
 require 'puppet/provider'
 require 'puppet/type/component'
 require 'puppet/type/pfile'
 require 'puppet/type/pfilebucket'
 require 'puppet/type/tidy'
 
 
 
 # $Id$
diff --git a/test/other/events.rb b/test/other/events.rb
index 10099fa46..078e6351f 100755
--- a/test/other/events.rb
+++ b/test/other/events.rb
@@ -1,169 +1,170 @@
 #!/usr/bin/env ruby
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppettest'
 
 # $Id$
 
 class TestEvents < Test::Unit::TestCase
 	include PuppetTest
     def teardown
         super
         Puppet::Event::Subscription.clear
     end
 
     def test_simplesubscribe
         name = tempfile()
         file = Puppet.type(:file).create(
             :name => name,
             :ensure => "file"
         )
         exec = Puppet.type(:exec).create(
             :name => "echo true",
             :path => "/usr/bin:/bin",
             :refreshonly => true,
             :subscribe => [[file.class.name, file.name]] 
         )
 
         comp = newcomp("eventtesting", file, exec)
 
         trans = assert_events([:file_created, :triggered], comp)
 
         assert_equal(1, trans.triggered?(exec, :refresh))
     end
 
     def test_simplerequire
         name = tempfile()
         file = Puppet.type(:file).create(
             :name => name,
             :ensure => "file"
         )
         exec = Puppet.type(:exec).create(
             :name => "echo true",
             :path => "/usr/bin:/bin",
             :refreshonly => true,
             :require => [[file.class.name, file.name]] 
         )
 
 
         comp = Puppet.type(:component).create(
             :name => "eventtesting"
         )
         comp.push exec
         trans = comp.evaluate
         events = nil
         assert_nothing_raised {
             events = trans.evaluate
         }
 
         assert_equal(1, events.length)
 
         assert_equal(0, trans.triggered?(exec, :refresh))
     end
 
     # Verify that one component can subscribe to another component and the "right"
     # thing happens
     def test_ladderrequire
         comps = {}
         objects = {}
         fname = tempfile()
         file = Puppet.type(:file).create(
             :name => tempfile(),
             :ensure => "file"
         )
 
         exec = Puppet.type(:exec).create(
             :name => "touch %s" % fname,
             :path => "/usr/bin:/bin",
             :refreshonly => true
         )
 
         fcomp = newcomp(file)
         ecomp = newcomp(exec)
         comp = newcomp("laddercomp", fcomp, ecomp)
 
         ecomp[:subscribe] = [[fcomp.class.name, fcomp.name]]
 
         comp.finalize
 
         trans = comp.evaluate
         events = nil
         assert_nothing_raised {
             events = trans.evaluate
         }
 
         assert(FileTest.exists?(fname), "#{fname} does not exist")
         #assert_equal(events.length, trans.triggered?(objects[:b], :refresh))
     end
 
     def test_multiplerefreshes
         files = []
 
         4.times { |i|
             files << Puppet.type(:file).create(
                 :name => tempfile(),
                 :ensure => "file"
             )
         }
 
         fname = tempfile()
         exec = Puppet.type(:exec).create(
             :name => "touch %s" % fname,
             :path => "/usr/bin:/bin",
             :refreshonly => true
         )
 
         exec[:subscribe] = files.collect { |f|
             ["file", f.name]
         }
 
         comp = newcomp(exec, *files)
 
         assert_apply(comp)
         assert(FileTest.exists?(fname), "Exec file did not get created")
     end
 
     # Make sure refreshing happens mid-transaction, rather than at the end.
     def test_refreshordering
         file = tempfile()
 
         exec1 = Puppet.type(:exec).create(
             :title => "one",
             :name => "echo one >> %s" % file,
             :path => "/usr/bin:/bin"
         )
 
         exec2 = Puppet.type(:exec).create(
             :title => "two",
             :name => "echo two >> %s" % file,
             :path => "/usr/bin:/bin",
             :refreshonly => true,
             :subscribe => exec1
         )
 
         exec3 = Puppet.type(:exec).create(
             :title => "three",
             :name => "echo three >> %s" % file,
-            :path => "/usr/bin:/bin"
+            :path => "/usr/bin:/bin",
+            :require => exec2
         )
         execs = [exec1, exec2, exec3]
 
         comp = newcomp(exec1,exec2,exec3)
         
         trans = comp.evaluate
         execs.each do |e| assert(trans.resources.vertex?(e), "%s is not in graph" % e.title) end
         trans.prepare
         execs.each do |e| assert(trans.relgraph.vertex?(e), "%s is not in relgraph" % e.title) end
         reverse = trans.relgraph.reversal
         execs.each do |e| assert(reverse.vertex?(e), "%s is not in reversed graph" % e.title) end
         
 
         assert_apply(comp)
 
         assert(FileTest.exists?(file), "File does not exist")
 
         assert_equal("one\ntwo\nthree\n", File.read(file))
     end
 end
diff --git a/test/other/pgraph.rb b/test/other/pgraph.rb
index 1ef853cc4..5ee76bfe9 100644
--- a/test/other/pgraph.rb
+++ b/test/other/pgraph.rb
@@ -1,126 +1,126 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2006-11-16.
 #  Copyright (c) 2006. All rights reserved.
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
 require 'puppettest/graph'
 
 class TestPGraph < Test::Unit::TestCase
 	include PuppetTest
 	include PuppetTest::Graph
 	
 	Edge = Puppet::Relationship
 	
 	def test_clear
 	    graph = Puppet::PGraph.new
 	    graph.add_edge!("a", "b")
 	    graph.add_vertex! "c"
 	    assert_nothing_raised do
 	        graph.clear
         end
         assert(graph.vertices.empty?, "Still have vertices after clear")
         assert(graph.edges.empty?, "still have edges after clear")
     end
 	    
 	
 	def test_matching_edges
 	    graph = Puppet::PGraph.new
 	    
 	    event = Puppet::Event.new(:source => "a", :event => :yay)
 	    none = Puppet::Event.new(:source => "a", :event => :NONE)
 	    
 	    edges = {}
 	    
 	    edges["a/b"] = Edge["a", "b", {:event => :yay, :callback => :refresh}]
 	    edges["a/c"] = Edge["a", "c", {:event => :yay, :callback => :refresh}]
 	    
 	    graph.add_edge!(edges["a/b"])
 	    
 	    # Try it for the trivial case of one target and a matching event
 	    assert_equal([edges["a/b"]], graph.matching_edges([event]))
 	    
 	    # Make sure we get nothing with a different event
 	    assert_equal([], graph.matching_edges([none]))
 	    
 	    # Set up multiple targets and make sure we get them all back
 	    graph.add_edge!(edges["a/c"])
 	    assert_equal([edges["a/b"], edges["a/c"]].sort, graph.matching_edges([event]).sort)
 	    assert_equal([], graph.matching_edges([none]))
     end
     
     def test_dependencies
         graph = Puppet::PGraph.new
         
         graph.add_edge!("a", "b")
         graph.add_edge!("a", "c")
         graph.add_edge!("b", "d")
         
-        assert_equal(%w{b c d}.sort, graph.dependencies("a").sort)
-        assert_equal(%w{d}.sort, graph.dependencies("b").sort)
-        assert_equal([].sort, graph.dependencies("c").sort)
+        assert_equal(%w{b c d}.sort, graph.dependents("a").sort)
+        assert_equal(%w{d}.sort, graph.dependents("b").sort)
+        assert_equal([].sort, graph.dependents("c").sort)
+        
+        assert_equal(%w{a b}, graph.dependencies("d").sort)
+        assert_equal(%w{a}, graph.dependencies("b").sort)
+        assert_equal(%w{a}, graph.dependencies("c").sort)
+        assert_equal([], graph.dependencies("a").sort)
+        
     end
     
     # Test that we can take a containment graph and rearrange it by dependencies
     def test_splice
         one, two, middle, top = build_tree
         empty = Container.new("empty", [])
         # Also, add an empty container to top
         top.push empty
         
         contgraph = top.to_graph
         
         # Now add a couple of child files, so that we can test whether all containers
         # get spliced, rather than just components.
         
         # Now make a dependency graph
         deps = Puppet::PGraph.new
         
         contgraph.vertices.each do |v|
             deps.add_vertex(v)
         end
         
         # We have to specify a relationship to our empty container, else it never makes it
         # into the dep graph in the first place.
         {one => two, "f" => "c", "h" => middle, "c" => empty}.each do |source, target|
             deps.add_edge!(source, target, :callback => :refresh)
         end
         
         deps.splice!(contgraph, Container)
         
         assert(! deps.cyclic?, "Created a cyclic graph")
         
         # Now make sure the containers got spliced correctly.
         contgraph.leaves(middle).each do |leaf|
             assert(deps.edge?("h", leaf), "no edge for h => %s" % leaf)
         end
         one.each do |oobj|
             two.each do |tobj|
                 assert(deps.edge?(oobj, tobj), "no %s => %s edge" % [oobj, tobj])
             end
         end
         
         # Make sure there are no container objects remaining
         c = deps.vertices.find_all { |v| v.is_a?(Container) }
         assert(c.empty?, "Still have containers %s" % c.inspect)
         
         nons = deps.vertices.find_all { |v| ! v.is_a?(String) }
         assert(nons.empty?,
             "still contain non-strings %s" % nons.inspect)
         
-        deps.to_jpg("deps-after")
-        
         deps.edges.each do |edge|
             assert_equal({:callback => :refresh}, edge.label,
                 "Label was not copied on splice")
         end
     end
-    
-    # Make sure empty containers are also removed
-    def test_empty_splice
-    end
 end
 
 # $Id$
diff --git a/test/other/transactions.rb b/test/other/transactions.rb
index 4190ada3a..256c815f7 100755
--- a/test/other/transactions.rb
+++ b/test/other/transactions.rb
@@ -1,771 +1,786 @@
 #!/usr/bin/env ruby
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppettest'
 require 'puppettest/support/resources'
 
 # $Id$
 
 class TestTransactions < Test::Unit::TestCase
     include PuppetTest::FileTesting
     include PuppetTest::Support::Resources
     
     def mkgenerator(&block)
         # Create a bogus type that generates new instances with shorter
         type = Puppet::Type.newtype(:generator) do
             newparam(:name, :namevar => true)
         end
         if block
             type.class_eval(&block)
         end
         cleanup do
             Puppet::Type.rmtype(:generator)
         end
         
         return type
     end
 
     def test_reports
         path1 = tempfile()
         path2 = tempfile()
         objects = []
         objects << Puppet::Type.newfile(
             :path => path1,
             :content => "yayness"
         )
         objects << Puppet::Type.newfile(
             :path => path2,
             :content => "booness"
         )
 
         trans = assert_events([:file_created, :file_created], *objects)
 
         report = nil
 
         assert_nothing_raised {
             report = trans.report
         }
 
         # First test the report logs
         assert(report.logs.length > 0, "Did not get any report logs")
 
         report.logs.each do |obj|
             assert_instance_of(Puppet::Log, obj)
         end
 
         # Then test the metrics
         metrics = report.metrics
 
         assert(metrics, "Did not get any metrics")
         assert(metrics.length > 0, "Did not get any metrics")
 
         assert(metrics.has_key?("resources"), "Did not get object metrics")
         assert(metrics.has_key?("changes"), "Did not get change metrics")
 
         metrics.each do |name, metric|
             assert_instance_of(Puppet::Metric, metric)
         end
     end
 
     def test_prefetch
         # Create a type just for testing prefetch
         name = :prefetchtesting
         $prefetched = false
         type = Puppet::Type.newtype(name) do
             newparam(:name) {}
         end
         
         cleanup do
             Puppet::Type.rmtype(name)
         end
 
         # Now create a provider
         type.provide(:prefetch) do
             def self.prefetch
                 $prefetched = true
             end
         end
 
         # Now create an instance
         inst = type.create :name => "yay"
         
         # Create a transaction
         trans = Puppet::Transaction.new(newcomp(inst))
 
         # Make sure prefetch works
         assert_nothing_raised do
             trans.prefetch
         end
 
         assert_equal(true, $prefetched, "type prefetch was not called")
 
         # Now make sure it gets called from within evaluate()
         $prefetched = false
         assert_nothing_raised do
             trans.evaluate
         end
 
         assert_equal(true, $prefetched, "evaluate did not call prefetch")
     end
 
     def test_refreshes_generate_events
         path = tempfile()
         firstpath = tempfile()
         secondpath = tempfile()
         file = Puppet::Type.newfile(:title => "file", :path => path, :content => "yayness")
         first = Puppet::Type.newexec(:title => "first",
                                      :command => "/bin/echo first > #{firstpath}",
                                      :subscribe => [:file, path],
                                      :refreshonly => true
         )
         second = Puppet::Type.newexec(:title => "second",
                                      :command => "/bin/echo second > #{secondpath}",
                                      :subscribe => [:exec, "first"],
                                      :refreshonly => true
         )
 
         assert_apply(file, first, second)
 
         assert(FileTest.exists?(secondpath), "Refresh did not generate an event")
     end
 
     unless %x{groups}.chomp.split(/ /).length > 1
         $stderr.puts "You must be a member of more than one group to test transactions"
     else
     def ingroup(gid)
         require 'etc'
         begin
             group = Etc.getgrgid(gid)
         rescue => detail
             puts "Could not retrieve info for group %s: %s" % [gid, detail]
             return nil
         end
 
         return @groups.include?(group.name)
     end
 
     def setup
         super
         @groups = %x{groups}.chomp.split(/ /)
         unless @groups.length > 1
             p @groups
             raise "You must be a member of more than one group to test this"
         end
     end
 
     def newfile(hash = {})
         tmpfile = tempfile()
         File.open(tmpfile, "w") { |f| f.puts rand(100) }
 
         # XXX now, because os x apparently somehow allows me to make a file
         # owned by a group i'm not a member of, i have to verify that
         # the file i just created is owned by one of my groups
         # grrr
         unless ingroup(File.stat(tmpfile).gid)
             Puppet.info "Somehow created file in non-member group %s; fixing" %
                 File.stat(tmpfile).gid
 
             require 'etc'
             firstgr = @groups[0]
             unless firstgr.is_a?(Integer)
                 str = Etc.getgrnam(firstgr)
                 firstgr = str.gid
             end
             File.chown(nil, firstgr, tmpfile)
         end
 
         hash[:name] = tmpfile
         assert_nothing_raised() {
             return Puppet.type(:file).create(hash)
         }
     end
 
     def newservice
         assert_nothing_raised() {
             return Puppet.type(:service).create(
                 :name => "sleeper",
                 :type => "init",
                 :path => exampledir("root/etc/init.d"),
                 :hasstatus => true,
                 :check => [:ensure]
             )
         }
     end
 
     def newexec(file)
         assert_nothing_raised() {
             return Puppet.type(:exec).create(
                 :name => "touch %s" % file,
                 :path => "/bin:/usr/bin:/sbin:/usr/sbin",
                 :returns => 0
             )
         }
     end
 
     # modify a file and then roll the modifications back
     def test_filerollback
         transaction = nil
         file = newfile()
 
         states = {}
         check = [:group,:mode]
         file[:check] = check
 
         assert_nothing_raised() {
             file.retrieve
         }
 
         assert_nothing_raised() {
             check.each { |state|
                 assert(file[state])
                 states[state] = file[state]
             }
         }
 
 
         component = newcomp("file",file)
         require 'etc'
         groupname = Etc.getgrgid(File.stat(file.name).gid).name
         assert_nothing_raised() {
             # Find a group that it's not set to
             group = @groups.find { |group| group != groupname }
             unless group
                 raise "Could not find suitable group"
             end
             file[:group] = group
 
             file[:mode] = "755"
         }
         trans = assert_events([:file_changed, :file_changed], component)
         file.retrieve
 
         assert_rollback_events(trans, [:file_changed, :file_changed], "file")
 
         assert_nothing_raised() {
             file.retrieve
         }
         states.each { |state,value|
             assert_equal(
                 value,file.is(state), "File %s remained %s" % [state, file.is(state)]
             )
         }
     end
 
     # start a service, and then roll the modification back
     # Disabled, because it wasn't really worth the effort.
     def disabled_test_servicetrans
         transaction = nil
         service = newservice()
 
         component = newcomp("service",service)
 
         assert_nothing_raised() {
             service[:ensure] = 1
         }
         service.retrieve
         assert(service.insync?, "Service did not start")
         system("ps -ef | grep ruby")
         trans = assert_events([:service_started], component)
         service.retrieve
 
         assert_rollback_events(trans, [:service_stopped], "service")
     end
 
     # test that services are correctly restarted and that work is done
     # in the right order
     def test_refreshing
         transaction = nil
         file = newfile()
         execfile = File.join(tmpdir(), "exectestingness")
         exec = newexec(execfile)
         states = {}
         check = [:group,:mode]
         file[:check] = check
         file[:group] = @groups[0]
 
         assert_apply(file)
 
         @@tmpfiles << execfile
 
         component = newcomp("both",file,exec)
 
         # 'subscribe' expects an array of arrays
         exec[:subscribe] = [[file.class.name,file.name]]
         exec[:refreshonly] = true
 
         assert_nothing_raised() {
             file.retrieve
             exec.retrieve
         }
 
         check.each { |state|
             states[state] = file[state]
         }
         assert_nothing_raised() {
             file[:mode] = "755"
         }
 
         trans = assert_events([:file_changed, :triggered], component)
 
         assert(FileTest.exists?(execfile), "Execfile does not exist")
         File.unlink(execfile)
         assert_nothing_raised() {
             file[:group] = @groups[1]
         }
 
         trans = assert_events([:file_changed, :triggered], component)
         assert(FileTest.exists?(execfile), "Execfile does not exist")
     end
 
     # Verify that one component requiring another causes the contained
     # resources in the requiring component to get refreshed.
     def test_refresh_across_two_components
         transaction = nil
         file = newfile()
         execfile = File.join(tmpdir(), "exectestingness2")
         @@tmpfiles << execfile
         exec = newexec(execfile)
         states = {}
         check = [:group,:mode]
         file[:check] = check
         file[:group] = @groups[0]
         assert_apply(file)
 
         fcomp = newcomp("file",file)
         ecomp = newcomp("exec",exec)
 
         component = newcomp("both",fcomp,ecomp)
 
         # 'subscribe' expects an array of arrays
         #component[:require] = [[file.class.name,file.name]]
         ecomp[:subscribe] = fcomp
         exec[:refreshonly] = true
 
         trans = assert_events([], component)
 
         assert_nothing_raised() {
             file[:group] = @groups[1]
             file[:mode] = "755"
         }
 
         trans = assert_events([:file_changed, :file_changed, :triggered], component)
     end
 
     # Make sure that multiple subscriptions get triggered.
     def test_multisubs
         path = tempfile()
         file1 = tempfile()
         file2 = tempfile()
         file = Puppet.type(:file).create(
             :path => path,
             :ensure => "file"
         )
         exec1 = Puppet.type(:exec).create(
             :path => ENV["PATH"],
             :command => "touch %s" % file1,
             :refreshonly => true,
             :subscribe => [:file, path]
         )
         exec2 = Puppet.type(:exec).create(
             :path => ENV["PATH"],
             :command => "touch %s" % file2,
             :refreshonly => true,
             :subscribe => [:file, path]
         )
 
         assert_apply(file, exec1, exec2)
         assert(FileTest.exists?(file1), "File 1 did not get created")
         assert(FileTest.exists?(file2), "File 2 did not get created")
     end
 
     # Make sure that a failed trigger doesn't result in other events not
     # getting triggered.
     def test_failedrefreshes
         path = tempfile()
         newfile = tempfile()
         file = Puppet.type(:file).create(
             :path => path,
             :ensure => "file"
         )
         svc = Puppet.type(:service).create(
             :name => "thisservicedoesnotexist",
             :subscribe => [:file, path]
         )
         exec = Puppet.type(:exec).create(
             :path => ENV["PATH"],
             :command => "touch %s" % newfile,
             :logoutput => true,
             :refreshonly => true,
             :subscribe => [:file, path]
         )
 
         assert_apply(file, svc, exec)
         assert(FileTest.exists?(path), "File did not get created")
         assert(FileTest.exists?(newfile), "Refresh file did not get created")
     end
 
     # Make sure that unscheduled and untagged objects still respond to events
     def test_unscheduled_and_untagged_response
         Puppet::Type.type(:schedule).mkdefaultschedules
         Puppet[:ignoreschedules] = false
         file = Puppet.type(:file).create(
             :name => tempfile(),
             :ensure => "file"
         )
 
         fname = tempfile()
         exec = Puppet.type(:exec).create(
             :name => "touch %s" % fname,
             :path => "/usr/bin:/bin",
             :schedule => "monthly",
             :subscribe => ["file", file.name]
         )
 
         comp = newcomp(file,exec)
         comp.finalize
 
         # Run it once
         assert_apply(comp)
         assert(FileTest.exists?(fname), "File did not get created")
 
         assert(!exec.scheduled?, "Exec is somehow scheduled")
 
         # Now remove it, so it can get created again
         File.unlink(fname)
 
         file[:content] = "some content"
 
         assert_events([:file_changed, :triggered], comp)
         assert(FileTest.exists?(fname), "File did not get recreated")
 
         # Now remove it, so it can get created again
         File.unlink(fname)
 
         # And tag our exec
         exec.tag("testrun")
 
         # And our file, so it runs
         file.tag("norun")
 
         Puppet[:tags] = "norun"
 
         file[:content] = "totally different content"
 
         assert(! file.insync?, "Uh, file is in sync?")
 
         assert_events([:file_changed, :triggered], comp)
         assert(FileTest.exists?(fname), "File did not get recreated")
     end
 
     def test_failed_reqs_mean_no_run
         exec = Puppet::Type.type(:exec).create(
             :command => "/bin/mkdir /this/path/cannot/possibly/exit",
             :title => "mkdir"
         )
 
         file1 = Puppet::Type.type(:file).create(
             :title => "file1",
             :path => tempfile(),
             :require => exec,
             :ensure => :file
         )
 
         file2 = Puppet::Type.type(:file).create(
             :title => "file2",
             :path => tempfile(),
             :require => file1,
             :ensure => :file
         )
 
         comp = newcomp(exec, file1, file2)
 
         comp.finalize
 
         assert_apply(comp)
 
         assert(! FileTest.exists?(file1[:path]),
             "File got created even tho its dependency failed")
         assert(! FileTest.exists?(file2[:path]),
             "File got created even tho its deep dependency failed")
     end
     end
     
     def f(n)
         Puppet::Type.type(:file)["/tmp/#{n.to_s}"]
     end
     
     def test_relationship_graph
         one, two, middle, top = mktree
         
         {one => two, "f" => "c", "h" => middle}.each do |source, target|
             if source.is_a?(String)
                 source = f(source)
             end
             if target.is_a?(String)
                 target = f(target)
             end
             target[:require] = source
         end
         
         trans = Puppet::Transaction.new(top)
         
         graph = nil
         assert_nothing_raised do
             graph = trans.relationship_graph
         end
         
         assert_instance_of(Puppet::PGraph, graph,
             "Did not get relationship graph")
         
         # Make sure all of the components are gone
         comps = graph.vertices.find_all { |v| v.is_a?(Puppet::Type::Component)}
         assert(comps.empty?, "Deps graph still contains components")
         
         # It must be reversed because of how topsort works
         sorted = graph.topsort.reverse
         
         # Now make sure the appropriate edges are there and are in the right order
         assert(graph.dependencies(f(:f)).include?(f(:c)),
             "c not marked a dep of f")
         assert(sorted.index(f(:c)) < sorted.index(f(:f)),
             "c is not before f")
             
         one.each do |o|
             two.each do |t|
                 assert(graph.dependencies(o).include?(t),
                     "%s not marked a dep of %s" % [t.ref, o.ref])
                 assert(sorted.index(t) < sorted.index(o),
                     "%s is not before %s" % [t.ref, o.ref])
             end
         end
         
         trans.resources.leaves(middle).each do |child|
             assert(graph.dependencies(f(:h)).include?(child),
                 "%s not marked a dep of h" % [child.ref])
             assert(sorted.index(child) < sorted.index(f(:h)),
                 "%s is not before h" % child.ref)
         end
         
         # Lastly, make sure our 'g' vertex made it into the relationship
         # graph, since it's not involved in any relationships.
         assert(graph.vertex?(f(:g)),
             "Lost vertexes with no relations")
 
         # Now make the reversal graph and make sure all of the vertices made it into that
         reverse = graph.reversal
         %w{a b c d e f g h}.each do |letter|
             file = f(letter)
             assert(reverse.vertex?(file), "%s did not make it into reversal" % letter)
         end
     end
     
     # Test pre-evaluation generation
     def test_generate
         mkgenerator() do
             def generate
                 ret = []
                 if title.length > 1
                     ret << self.class.create(:title => title[0..-2])
                 else
                     return nil
                 end
                 ret
             end
         end
         
         yay = Puppet::Type.newgenerator :title => "yay"
         rah = Puppet::Type.newgenerator :title => "rah"
         comp = newcomp(yay, rah)
         trans = comp.evaluate
         
         assert_nothing_raised do
             trans.generate
         end
         
         %w{ya ra y r}.each do |name|
             assert(trans.resources.vertex?(Puppet::Type.type(:generator)[name]),
                 "Generated %s was not a vertex" % name)
         end
         
         # Now make sure that cleanup gets rid of those generated types.
         assert_nothing_raised do
             trans.cleanup
         end
         
         %w{ya ra y r}.each do |name|
             assert(!trans.resources.vertex?(Puppet::Type.type(:generator)[name]),
                 "Generated vertex %s was not removed from graph" % name)
             assert_nil(Puppet::Type.type(:generator)[name],
                 "Generated vertex %s was not removed from class" % name)
         end
     end
     
     # Test mid-evaluation generation.
     def test_eval_generate
         $evaluated = []
         type = mkgenerator() do
             def eval_generate
                 ret = []
                 if title.length > 1
                     ret << self.class.create(:title => title[0..-2])
                 else
                     return nil
                 end
                 ret
             end
             
             def evaluate
                 $evaluated << self.title
                 return []
             end
         end
 
         yay = Puppet::Type.newgenerator :title => "yay"
         rah = Puppet::Type.newgenerator :title => "rah", :subscribe => yay
         comp = newcomp(yay, rah)
         trans = comp.evaluate
         
         trans.prepare
         
         # Now apply the resources, and make sure they appropriately generate
         # things.
         assert_nothing_raised("failed to apply yay") do
             trans.eval_resource(yay)
         end
         ya = type["ya"]
         assert(ya, "Did not generate ya")
         assert(trans.relgraph.vertex?(ya),
             "Did not add ya to rel_graph")
         
         # Now make sure the appropriate relationships were added
         assert(trans.relgraph.edge?(yay, ya),
             "parent was not required by child")
         assert(trans.relgraph.edge?(ya, rah),
             "rah was not subscribed to ya")
         
         # And make sure the relationship is a subscription with a callback,
         # not just a require.
         assert_equal({:callback => :refresh, :event => :ALL_EVENTS},
             trans.relgraph[Puppet::Relationship.new(ya, rah)],
             "The label was not retained")
         
         # Now make sure it in turn eval_generates appropriately
         assert_nothing_raised("failed to apply yay") do
             trans.eval_resource(type["ya"])
         end
 
         %w{y}.each do |name|
             res = type[name]
             assert(res, "Did not generate %s" % name)
             assert(trans.relgraph.vertex?(res),
                 "Did not add %s to rel_graph" % name)
         end
         
         assert_nothing_raised("failed to eval_generate with nil response") do
             trans.eval_resource(type["y"])
         end
         assert(trans.relgraph.edge?(yay, ya), "no edge was created for ya => yay")
         
         assert_nothing_raised("failed to apply rah") do
             trans.eval_resource(rah)
         end
 
         ra = type["ra"]
         assert(ra, "Did not generate ra")
         assert(trans.relgraph.vertex?(ra),
             "Did not add ra to rel_graph" % name)
         
         # Now make sure this generated resource has the same relationships as the generating
         # resource
         assert(trans.relgraph.edge?(yay, ra),
             "yay is not required by ra")
         assert(trans.relgraph.edge?(ya, ra),
             "ra is not subscribed to ya")
         
         # And make sure the relationship is a subscription with a callback,
         # not just a require.
         assert_equal({:callback => :refresh, :event => :ALL_EVENTS},
             trans.relgraph[Puppet::Relationship.new(ya, ra)],
             "The label was not retained")
         
         # Now make sure that cleanup gets rid of those generated types.
         assert_nothing_raised do
             trans.cleanup
         end
         
         %w{ya ra y r}.each do |name|
             assert(!trans.relgraph.vertex?(type[name]),
                 "Generated vertex %s was not removed from graph" % name)
             assert_nil(type[name],
                 "Generated vertex %s was not removed from class" % name)
         end
         
         # Now, start over and make sure that everything gets evaluated.
         trans = comp.evaluate
         $evaluated.clear
         assert_nothing_raised do
             trans.evaluate
         end
         
         assert_equal(%w{yay ya y rah ra r}, $evaluated,
             "Not all resources were evaluated or not in the right order")
     end
     
     def test_tags
         res = Puppet::Type.newfile :path => tempfile()
         comp = newcomp(res)
         
         # Make sure they default to none
         assert_equal([], comp.evaluate.tags)
         
         # Make sure we get the main tags
         Puppet[:tags] = %w{this is some tags}
         assert_equal(%w{this is some tags}, comp.evaluate.tags)
         
         # And make sure they get processed correctly
         Puppet[:tags] = ["one", "two,three", "four"]
         assert_equal(%w{one two three four}, comp.evaluate.tags)
         
         # lastly, make sure we can override them
         trans = comp.evaluate
         trans.tags = ["one", "two,three", "four"]
         assert_equal(%w{one two three four}, comp.evaluate.tags)
     end
     
     def test_tagged?
         res = Puppet::Type.newfile :path => tempfile()
         comp = newcomp(res)
         trans = comp.evaluate
         
         assert(trans.tagged?(res), "tagged? defaulted to false")
         
         # Now set some tags
         trans.tags = %w{some tags}
         
         # And make sure it's false
         assert(! trans.tagged?(res), "matched invalid tags")
         
         # Set ignoretags and make sure it sticks
         trans.ignoretags = true
         assert(trans.tagged?(res), "tags were not ignored")
         
         # Now make sure we actually correctly match tags
         res[:tag] = "mytag"
         trans.ignoretags = false
         trans.tags = %w{notag}
         
         assert(! trans.tagged?(res), "tags incorrectly matched")
         
         trans.tags = %w{mytag yaytag}
         assert(trans.tagged?(res), "tags should have matched")
-        
     end
     
-    # Make sure events propagate down the relationship graph appropriately.
-    def test_trigger
+    # We don't want to purge resources that have relationships with other resources,
+    # so we want our transactions to check for that.
+    def test_required_resources_not_deleted
+        @file = Puppet::Type.type(:file)
+        path1 = tempfile()
+        path2 = tempfile()
+        
+        # Create our first file
+        File.open(path1, "w") { |f| f.puts "yay" }
+        
+        # Create a couple of related resources
+        file1 = @file.create :title => "dependee", :path => path1, :ensure => :absent
+        file2 = @file.create :title => "depender", :path => path2, :content => "some stuff", :require => file1
+                
+        # Now make sure we don't actually delete the first file
+        assert_apply(file1, file2)
+        
+        assert(FileTest.exists?(path1), "required file was deleted")
     end
 end
 
 # $Id$
diff --git a/test/types/file.rb b/test/types/file.rb
index c57129cd5..917b2e755 100755
--- a/test/types/file.rb
+++ b/test/types/file.rb
@@ -1,1766 +1,1774 @@
 #!/usr/bin/env ruby
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'fileutils'
 require 'puppettest'
 
 class TestFile < Test::Unit::TestCase
     include PuppetTest::FileTesting
     # hmmm
     # this is complicated, because we store references to the created
     # objects in a central store
     def mkfile(hash)
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(hash)
         }
         return file
     end
 
     def mktestfile
         # because luke's home directory is on nfs, it can't be used for testing
         # as root
         tmpfile = tempfile()
         File.open(tmpfile, "w") { |f| f.puts rand(100) }
         @@tmpfiles.push tmpfile
         mkfile(:name => tmpfile)
     end
 
     def setup
         super
         @file = Puppet::Type.type(:file)
         begin
             initstorage
         rescue
             system("rm -rf %s" % Puppet[:statefile])
         end
     end
 
     def teardown
         Puppet::Storage.clear
         system("rm -rf %s" % Puppet[:statefile])
         super
     end
 
     def initstorage
         Puppet::Storage.init
         Puppet::Storage.load
     end
 
     def clearstorage
         Puppet::Storage.store
         Puppet::Storage.clear
     end
 
     def test_owner
         file = mktestfile()
 
         users = {}
         count = 0
 
         # collect five users
         Etc.passwd { |passwd|
             if count > 5
                 break
             else
                 count += 1
             end
             users[passwd.uid] = passwd.name
         }
 
         fake = {}
         # find a fake user
         while true
             a = rand(1000)
             begin
                 Etc.getpwuid(a)
             rescue
                 fake[a] = "fakeuser"
                 break
             end
         end
 
         uid, name = users.shift
         us = {}
         us[uid] = name
         users.each { |uid, name|
             assert_apply(file)
             assert_nothing_raised() {
                 file[:owner] = name
             }
             assert_nothing_raised() {
                 file.retrieve
             }
             assert_apply(file)
         }
     end
 
     def test_group
         file = mktestfile()
         [%x{groups}.chomp.split(/ /), Process.groups].flatten.each { |group|
             assert_nothing_raised() {
                 file[:group] = group
             }
             assert(file.state(:group))
             assert(file.state(:group).should)
         }
     end
 
     if Puppet::SUIDManager.uid == 0
         def test_createasuser
             dir = tmpdir()
 
             user = nonrootuser()
             path = File.join(tmpdir, "createusertesting")
             @@tmpfiles << path
 
             file = nil
             assert_nothing_raised {
                 file = Puppet.type(:file).create(
                     :path => path,
                     :owner => user.name,
                     :ensure => "file",
                     :mode => "755"
                 )
             }
 
             comp = newcomp("createusertest", file)
 
             assert_events([:file_created], comp)
         end
 
         def test_nofollowlinks
             basedir = tempfile()
             Dir.mkdir(basedir)
             file = File.join(basedir, "file")
             link = File.join(basedir, "link")
 
             File.open(file, "w", 0644) { |f| f.puts "yayness"; f.flush }
             File.symlink(file, link)
 
             # First test 'user'
             user = nonrootuser()
 
             inituser = File.lstat(link).uid
             File.lchown(inituser, nil, link)
 
             obj = nil
             assert_nothing_raised {
                 obj = Puppet.type(:file).create(
                     :title => link,
                     :owner => user.name
                 )
             }
             obj.retrieve
 
             # Make sure it defaults to managing the link
             assert_events([:file_changed], obj)
             assert_equal(user.uid, File.lstat(link).uid)
             assert_equal(inituser, File.stat(file).uid)
             File.chown(inituser, nil, file)
             File.lchown(inituser, nil, link)
 
             # Try following
             obj[:links] = :follow
             assert_events([:file_changed], obj)
             assert_equal(user.uid, File.stat(file).uid)
             assert_equal(inituser, File.lstat(link).uid)
 
             # And then explicitly managing
             File.chown(inituser, nil, file)
             File.lchown(inituser, nil, link)
             obj[:links] = :manage
             assert_events([:file_changed], obj)
             assert_equal(user.uid, File.lstat(link).uid)
             assert_equal(inituser, File.stat(file).uid)
 
             obj.delete(:owner)
             obj[:links] = :ignore
 
             # And then test 'group'
             group = nonrootgroup
 
             initgroup = File.stat(file).gid
             obj[:group] = group.name
 
             assert_events([:file_changed], obj)
             assert_equal(initgroup, File.stat(file).gid)
             assert_equal(group.gid, File.lstat(link).gid)
             File.chown(nil, initgroup, file)
             File.lchown(nil, initgroup, link)
 
             obj[:links] = :follow
             assert_events([:file_changed], obj)
             assert_equal(group.gid, File.stat(file).gid)
             File.chown(nil, initgroup, file)
             File.lchown(nil, initgroup, link)
 
             obj[:links] = :manage
             assert_events([:file_changed], obj)
             assert_equal(group.gid, File.lstat(link).gid)
             assert_equal(initgroup, File.stat(file).gid)
         end
 
         def test_ownerasroot
             file = mktestfile()
 
             users = {}
             count = 0
 
             # collect five users
             Etc.passwd { |passwd|
                 if count > 5
                     break
                 else
                     count += 1
                 end
                 next if passwd.uid < 0
                 users[passwd.uid] = passwd.name
             }
 
             fake = {}
             # find a fake user
             while true
                 a = rand(1000)
                 begin
                     Etc.getpwuid(a)
                 rescue
                     fake[a] = "fakeuser"
                     break
                 end
             end
 
             users.each { |uid, name|
                 assert_nothing_raised() {
                     file[:owner] = name
                 }
                 changes = []
                 assert_nothing_raised() {
                     changes << file.evaluate
                 }
                 assert(changes.length > 0)
                 assert_apply(file)
                 file.retrieve
                 assert(file.insync?())
                 assert_nothing_raised() {
                     file[:owner] = uid
                 }
                 assert_apply(file)
                 file.retrieve
                 # make sure changing to number doesn't cause a sync
                 assert(file.insync?())
             }
 
             # We no longer raise an error here, because we check at run time
             #fake.each { |uid, name|
             #    assert_raise(Puppet::Error) {
             #        file[:owner] = name
             #    }
             #    assert_raise(Puppet::Error) {
             #        file[:owner] = uid
             #    }
             #}
         end
 
         def test_groupasroot
             file = mktestfile()
             [%x{groups}.chomp.split(/ /), Process.groups].flatten.each { |group|
                 assert_nothing_raised() {
                     file[:group] = group
                 }
                 assert(file.state(:group))
                 assert(file.state(:group).should)
                 assert_apply(file)
                 file.retrieve
                 assert(file.insync?())
                 assert_nothing_raised() {
                     file.delete(:group)
                 }
             }
         end
 
         if Facter.value(:operatingsystem) == "Darwin"
             def test_sillyowner
                 file = tempfile()
                 File.open(file, "w") { |f| f.puts "" }
                 File.chown(-2, nil, file)
 
                 assert(File.stat(file).uid > 120000, "eh?")
                 user = nonrootuser
                 obj = Puppet::Type.newfile(
                     :path => file,
                     :owner => user.name
                 )
 
                 assert_apply(obj)
 
                 assert_equal(user.uid, File.stat(file).uid)
             end
         end
     else
         $stderr.puts "Run as root for complete owner and group testing"
     end
 
     def test_create
         %w{a b c d}.collect { |name| tempfile() + name.to_s }.each { |path|
             file =nil
             assert_nothing_raised() {
                 file = Puppet.type(:file).create(
                     :name => path,
                     :ensure => "file"
                 )
             }
             assert_events([:file_created], file)
             assert_events([], file)
             assert(FileTest.file?(path), "File does not exist")
             assert(file.insync?())
             @@tmpfiles.push path
         }
     end
 
     def test_create_dir
         basedir = tempfile()
         Dir.mkdir(basedir)
         %w{a b c d}.collect { |name| "#{basedir}/%s" % name }.each { |path|
             file = nil
             assert_nothing_raised() {
                 file = Puppet.type(:file).create(
                     :name => path,
                     :ensure => "directory"
                 )
             }
             assert(! FileTest.directory?(path), "Directory %s already exists" %
                 [path])
             assert_events([:directory_created], file)
             assert_events([], file)
             assert(file.insync?())
             assert(FileTest.directory?(path))
             @@tmpfiles.push path
         }
     end
 
     def test_modes
         file = mktestfile
         # Set it to something else initially
         File.chmod(0775, file.title)
         [0644,0755,0777,0641].each { |mode|
             assert_nothing_raised() {
                 file[:mode] = mode
             }
             assert_events([:file_changed], file)
             assert_events([], file)
 
             assert(file.insync?())
 
             assert_nothing_raised() {
                 file.delete(:mode)
             }
         }
     end
 
     def test_checksums
         types = %w{md5 md5lite timestamp time}
         exists = "/tmp/sumtest-exists"
         nonexists = "/tmp/sumtest-nonexists"
 
         @@tmpfiles << exists
         @@tmpfiles << nonexists
 
         # try it both with files that exist and ones that don't
         files = [exists, nonexists]
         initstorage
         File.open(exists,File::CREAT|File::TRUNC|File::WRONLY) { |of|
             of.puts "initial text"
         }
         types.each { |type|
             files.each { |path|
                 if Puppet[:debug]
                     Puppet.warning "Testing %s on %s" % [type,path]
                 end
                 file = nil
                 events = nil
                 # okay, we now know that we have a file...
                 assert_nothing_raised() {
                     file = Puppet.type(:file).create(
                         :name => path,
                         :ensure => "file",
                         :checksum => type
                     )
                 }
                 trans = nil
 
                 file.retrieve
 
                 if file.title !~ /nonexists/
                     sum = file.state(:checksum)
                     assert(sum.insync?, "file is not in sync")
                 end
 
                 events = assert_apply(file)
 
                 assert(! events.include?(:file_changed),
                     "File incorrectly changed")
                 assert_events([], file)
 
                 # We have to sleep because the time resolution of the time-based
                 # mechanisms is greater than one second
                 sleep 1 if type =~ /time/
 
                 assert_nothing_raised() {
                     File.open(path,File::CREAT|File::TRUNC|File::WRONLY) { |of|
                         of.puts "some more text, yo"
                     }
                 }
                 Puppet.type(:file).clear
 
                 # now recreate the file
                 assert_nothing_raised() {
                     file = Puppet.type(:file).create(
                         :name => path,
                         :checksum => type
                     )
                 }
                 trans = nil
 
                 assert_events([:file_changed], file)
 
                 # Run it a few times to make sure we aren't getting
                 # spurious changes.
                 assert_nothing_raised do
                     file.state(:checksum).retrieve
                 end
                 assert(file.state(:checksum).insync?,
                     "checksum is not in sync")
 
                 sleep 1.1 if type =~ /time/
                 assert_nothing_raised() {
                     File.unlink(path)
                     File.open(path,File::CREAT|File::TRUNC|File::WRONLY) { |of|
                         # We have to put a certain amount of text in here or
                         # the md5-lite test fails
                         2.times {
                             of.puts rand(100)
                         }
                         of.flush
                     }
                 }
                 assert_events([:file_changed], file)
 
                 # verify that we're actually getting notified when a file changes
                 assert_nothing_raised() {
                     Puppet.type(:file).clear
                 }
 
                 if path =~ /nonexists/
                     File.unlink(path)
                 end
             }
         }
     end
 
     def cyclefile(path)
         # i had problems with using :name instead of :path
         [:name,:path].each { |param|
             file = nil
             changes = nil
             comp = nil
             trans = nil
 
             initstorage
             assert_nothing_raised {
                 file = Puppet.type(:file).create(
                     param => path,
                     :recurse => true,
                     :checksum => "md5"
                 )
             }
             comp = Puppet.type(:component).create(
                 :name => "component"
             )
             comp.push file
             assert_nothing_raised {
                 trans = comp.evaluate
             }
             assert_nothing_raised {
                 trans.evaluate
             }
             clearstorage
             Puppet::Type.allclear
         }
     end
     
     def test_localrecurse
         # Create a test directory
         path = tempfile()
         dir = @file.create :path => path, :mode => 0755, :recurse => true
         
         Dir.mkdir(path)
         
         # Make sure we return nothing when there are no children
         ret = nil
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal([], ret, "empty dir returned children")
         
         # Now make a file and make sure we get it
         test = File.join(path, "file")
         File.open(test, "w") { |f| f.puts "yay" }
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         fileobj = @file[test]
         assert(fileobj, "child object was not created")
         assert_equal([fileobj], ret, "child object was not returned")
         
         # check that the file lists us as a dependency
         assert_equal([[:file, dir.title]], fileobj[:require], "dependency was not set up")
         
         # And that it inherited our recurse setting
         assert_equal(true, fileobj[:recurse], "file did not inherit recurse")
         
         # Make sure it's not returned again
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal([], ret, "child object was returned twice")
         
         # Now just for completion, make sure we will return many files
         files = []
         10.times do |i|
             f = File.join(path, i.to_s)
             files << f
             File.open(f, "w") do |o| o.puts "" end
         end
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal(files.sort, ret.collect { |f| f.title }, "child object was returned twice")
         
         # Clean everything up and start over
         files << test
         files.each do |f| File.unlink(f) end
         
         # Now make sure we correctly ignore things
         dir[:ignore] = "*.out"
         bad = File.join(path, "test.out")
         good = File.join(path, "yayness")
         [good, bad].each do |f|
             File.open(f, "w") { |o| o.puts "" }
         end
         
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal([good], ret.collect { |f| f.title }, "ignore failed")
         
         # Now make sure purging works
         dir[:purge] = true
         dir[:ignore] = "svn"
         
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal([bad], ret.collect { |f| f.title }, "purge failed")
         
         badobj = @file[bad]
         assert(badobj, "did not create bad object")
         assert_equal(:absent, badobj.should(:ensure), "ensure was not set to absent on bad object")
     end
     
     def test_recurse
         basedir = tempfile()
         FileUtils.mkdir_p(basedir)
         
         # Create our file
         dir = nil
         assert_nothing_raised {
             dir = Puppet.type(:file).create(
                 :path => basedir,
                 :check => %w{owner mode group}
             )
         }
         
         return_nil = false
         
         # and monkey-patch it
         [:localrecurse, :sourcerecurse, :linkrecurse].each do |m|
             dir.meta_def(m) do |recurse|
                 if return_nil # for testing nil return, of course
                     return nil
                 else
                     return [recurse]
                 end
             end
         end
         
         # First try it with recurse set to false
         dir[:recurse] = false
         assert_nothing_raised do
             assert_nil(dir.recurse)
         end
         
         # Now try it with the different valid positive values
         [true, "true", "inf", 50].each do |value|
             assert_nothing_raised { dir[:recurse] = value}
             
             # Now make sure the methods are called appropriately
             ret = nil
             assert_nothing_raised do
                 ret = dir.recurse
             end
             
             # We should only call the localrecurse method, so make sure
             # that's the case
             if value == 50
                 # Make sure our counter got decremented
                 assert_equal([49], ret, "did not call localrecurse")
             else
                 assert_equal([true], ret, "did not call localrecurse")
             end
         end
         
         # Make sure it doesn't recurse when we've set recurse to false
         [false, "false"].each do |value|
             assert_nothing_raised { dir[:recurse] = value }
             
             ret = nil
             assert_nothing_raised() { ret = dir.recurse }
             assert_nil(ret)
         end
         dir[:recurse] = true
         
         # Now add a target, so we do the linking thing
         dir[:target] = tempfile()
         ret = nil
         assert_nothing_raised { ret = dir.recurse }
         assert_equal([true, true], ret, "did not call linkrecurse")
         
         # And add a source, and make sure we call that
         dir[:source] = tempfile()
         assert_nothing_raised { ret = dir.recurse }
         assert_equal([true, true, true], ret, "did not call linkrecurse")
         
         # Lastly, make sure we correctly handle returning nil
         return_nil = true
         assert_nothing_raised { ret = dir.recurse }
     end
     
     def test_recurse?
         file = Puppet::Type.type(:file).create :path => tempfile
         
         # Make sure we default to false
         assert(! file.recurse?, "Recurse defaulted to true")
         
         [true, "true", 10, "inf"].each do |value|
             file[:recurse] = value
             assert(file.recurse?, "%s did not cause recursion" % value)
         end
         
         [false, "false", 0].each do |value|
             file[:recurse] = value
             assert(! file.recurse?, "%s caused recursion" % value)
         end
     end
     
     def test_recursion
         basedir = tempfile()
         subdir = File.join(basedir, "subdir")
         tmpfile = File.join(basedir,"testing")
         FileUtils.mkdir_p(subdir)
 
         dir = nil
         [true, "true", "inf", 50].each do |value|
             assert_nothing_raised {
                 dir = Puppet.type(:file).create(
                     :path => basedir,
                     :recurse => value,
                     :check => %w{owner mode group}
                 )
             }
             
             children = nil
 
             assert_nothing_raised {
                 children = dir.eval_generate
             }
             
             assert_equal([subdir], children.collect {|c| c.title },
                 "Incorrect generated children")
             
             dir.class[subdir].remove
 
             File.open(tmpfile, "w") { |f| f.puts "yayness" }
             
             assert_nothing_raised {
                 children = dir.eval_generate
             }
 
             assert_equal([subdir, tmpfile].sort, children.collect {|c| c.title }.sort,
                 "Incorrect generated children")
             
             File.unlink(tmpfile)
             #system("rm -rf %s" % basedir)
             Puppet.type(:file).clear
         end
     end
 
     def test_filetype_retrieval
         file = nil
 
         # Verify it retrieves files of type directory
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => tmpdir(),
                 :check => :type
             )
         }
 
         assert_nothing_raised {
             file.evaluate
         }
 
         assert_equal("directory", file.state(:type).is)
 
         # And then check files
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => tempfile(),
                 :ensure => "file"
             )
         }
 
         assert_apply(file)
         file[:check] = "type"
         assert_apply(file)
 
         assert_equal("file", file.state(:type).is)
 
         file[:type] = "directory"
 
         assert_nothing_raised { file.retrieve }
 
         # The 'retrieve' method sets @should to @is, so they're never
         # out of sync.  It's a read-only class.
         assert(file.insync?)
     end
 
     def test_remove
         basedir = tempfile()
         subdir = File.join(basedir, "this")
         FileUtils.mkdir_p(subdir)
 
         dir = nil
         assert_nothing_raised {
             dir = Puppet.type(:file).create(
                 :path => basedir,
                 :recurse => true,
                 :check => %w{owner mode group}
             )
         }
 
         assert_nothing_raised {
             dir.eval_generate
         }
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet.type(:file)[subdir]
         }
 
         assert(obj, "Could not retrieve subdir object")
 
         assert_nothing_raised {
             obj.remove(true)
         }
 
         assert_nothing_raised {
             obj = Puppet.type(:file)[subdir]
         }
 
         assert_nil(obj, "Retrieved removed object")
     end
 
     def test_path
         dir = tempfile()
 
         path = File.join(dir, "subdir")
 
         assert_nothing_raised("Could not make file") {
             FileUtils.mkdir_p(File.dirname(path))
             File.open(path, "w") { |f| f.puts "yayness" }
         }
 
         file = nil
         dirobj = nil
         assert_nothing_raised("Could not make file object") {
             dirobj = Puppet.type(:file).create(
                 :path => dir,
                 :recurse => true,
                 :check => %w{mode owner group}
             )
         }
 
         assert_nothing_raised {
             dirobj.eval_generate
         }
 
         assert_nothing_raised {
             file = dirobj.class[path]
         }
 
         assert(file, "Could not retrieve file object")
 
         assert_equal("file=%s" % file.title, file.path)
     end
 
     def test_autorequire
         basedir = tempfile()
         subfile = File.join(basedir, "subfile")
 
         baseobj = Puppet.type(:file).create(
             :name => basedir,
             :ensure => "directory"
         )
 
         subobj = Puppet.type(:file).create(
             :name => subfile,
             :ensure => "file"
         )
         edge = nil
         assert_nothing_raised do
             edge = subobj.autorequire.shift
         end
         assert_equal(baseobj, edge.source, "file did not require its parent dir")
         assert_equal(subobj, edge.target, "file did not require its parent dir")
     end
 
     def test_content
         file = tempfile()
         str = "This is some content"
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet.type(:file).create(
                 :name => file,
                 :content => str
             )
         }
 
         assert(!obj.insync?, "Object is incorrectly in sync")
 
         assert_events([:file_created], obj)
 
         obj.retrieve
 
         assert(obj.insync?, "Object is not in sync")
 
         text = File.read(file)
 
         assert_equal(str, text, "Content did not copy correctly")
 
         newstr = "Another string, yo"
 
         obj[:content] = newstr
 
         assert(!obj.insync?, "Object is incorrectly in sync")
 
         assert_events([:file_changed], obj)
 
         text = File.read(file)
 
         assert_equal(newstr, text, "Content did not copy correctly")
 
         obj.retrieve
         assert(obj.insync?, "Object is not in sync")
     end
 
     # Unfortunately, I know this fails
     def disabled_test_recursivemkdir
         path = tempfile()
         subpath = File.join(path, "this", "is", "a", "dir")
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => subpath,
                 :ensure => "directory",
                 :recurse => true
             )
         }
 
         comp = newcomp("yay", file)
         comp.finalize
         assert_apply(comp)
         #assert_events([:directory_created], comp)
 
         assert(FileTest.directory?(subpath), "Did not create directory")
     end
 
     # Make sure that content updates the checksum on the same run
     def test_checksumchange_for_content
         dest = tempfile()
         File.open(dest, "w") { |f| f.puts "yayness" }
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => dest,
                 :checksum => "md5",
                 :content => "This is some content"
             )
         }
 
         file.retrieve
 
         assert_events([:file_changed], file)
         file.retrieve
         assert_events([], file)
     end
 
     # Make sure that content updates the checksum on the same run
     def test_checksumchange_for_ensure
         dest = tempfile()
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => dest,
                 :checksum => "md5",
                 :ensure => "file"
             )
         }
 
         file.retrieve
 
         assert_events([:file_created], file)
         file.retrieve
         assert_events([], file)
     end
 
     # Make sure that content gets used before ensure
     def test_contentbeatsensure
         dest = tempfile()
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => dest,
                 :ensure => "file",
                 :content => "this is some content, yo"
             )
         }
 
         file.retrieve
 
         assert_events([:file_created], file)
         file.retrieve
         assert_events([], file)
         assert_events([], file)
     end
 
     def test_nameandpath
         path = tempfile()
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :title => "fileness",
                 :path => path,
                 :content => "this is some content"
             )
         }
 
         assert_apply(file)
 
         assert(FileTest.exists?(path))
     end
 
     # Make sure that a missing group isn't fatal at object instantiation time.
     def test_missinggroup
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :path => tempfile(),
                 :group => "fakegroup"
             )
         }
 
         assert(file.state(:group), "Group state failed")
     end
 
     def test_modecreation
         path = tempfile()
         file = Puppet.type(:file).create(
             :path => path,
             :ensure => "file",
             :mode => "0777"
         )
         assert_apply(file)
         assert_equal(0777, File.stat(path).mode & 007777)
         File.unlink(path)
         file[:ensure] = "directory"
         assert_apply(file)
         assert_equal(0777, File.stat(path).mode & 007777)
     end
 
     def test_followlinks
         basedir = tempfile()
         Dir.mkdir(basedir)
         file = File.join(basedir, "file")
         link = File.join(basedir, "link")
 
         File.open(file, "w", 0644) { |f| f.puts "yayness"; f.flush }
         File.symlink(file, link)
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet.type(:file).create(
                 :path => link,
                 :mode => "755"
             )
         }
         obj.retrieve
 
         assert_events([], obj)
 
         # Assert that we default to not following links
         assert_equal("%o" % 0644, "%o" % (File.stat(file).mode & 007777))
 
         # Assert that we can manage the link directly, but modes still don't change
         obj[:links] = :manage
         assert_events([], obj)
 
         assert_equal("%o" % 0644, "%o" % (File.stat(file).mode & 007777))
 
         obj[:links] = :follow
         assert_events([:file_changed], obj)
 
         assert_equal("%o" % 0755, "%o" % (File.stat(file).mode & 007777))
 
         # Now verify that content and checksum don't update, either
         obj.delete(:mode)
         obj[:checksum] = "md5"
         obj[:links] = :ignore
 
         assert_events([], obj)
         File.open(file, "w") { |f| f.puts "more text" }
         assert_events([], obj)
         obj[:links] = :follow
         assert_events([], obj)
         File.open(file, "w") { |f| f.puts "even more text" }
         assert_events([:file_changed], obj)
 
         obj.delete(:checksum)
         obj[:content] = "this is some content"
         obj[:links] = :ignore
 
         assert_events([], obj)
         File.open(file, "w") { |f| f.puts "more text" }
         assert_events([], obj)
         obj[:links] = :follow
         assert_events([:file_changed], obj)
     end
 
     # If both 'ensure' and 'content' are used, make sure that all of the other
     # states are handled correctly.
     def test_contentwithmode
         path = tempfile()
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :path => path,
                 :ensure => "file",
                 :content => "some text\n",
                 :mode => 0755
             )
         }
 
         assert_apply(file)
         assert_equal("%o" % 0755, "%o" % (File.stat(path).mode & 007777))
     end
 
     # Make sure we can create symlinks
     def test_symlinks
         path = tempfile()
         link = tempfile()
 
         File.open(path, "w") { |f| f.puts "yay" }
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :title => "somethingelse",
                 :ensure => path,
                 :path => link
             )
         }
 
         assert_events([:link_created], file)
 
         assert(FileTest.symlink?(link), "Link was not created")
 
         assert_equal(path, File.readlink(link), "Link was created incorrectly")
 
         # Make sure running it again works
         assert_events([], file)
         assert_events([], file)
         assert_events([], file)
     end
     
     def test_linkrecurse
         dest = tempfile()
         link = @file.create :path => tempfile(), :recurse => true, :ensure => dest
         
         ret = nil
         
         # Start with nothing, just to make sure we get nothing back
         assert_nothing_raised { ret = link.linkrecurse(true) }
         assert_nil(ret, "got a return when the dest doesn't exist")
         
         # then with a directory with only one file
         Dir.mkdir(dest)
         one = File.join(dest, "one")
         File.open(one, "w") { |f| f.puts "" }
         link[:ensure] = dest
         assert_nothing_raised { ret = link.linkrecurse(true) }
         
         assert_equal(:directory, link.should(:ensure), "ensure was not set to directory")
         assert_equal([File.join(link.title, "one")], ret.collect { |f| f.title },
             "Did not get linked file")
         oneobj = @file[File.join(link.title, "one")]
         assert_equal(one, oneobj.should(:target), "target was not set correctly")
         
         oneobj.remove
         File.unlink(one)
         
         # Then make sure we get multiple files
         returns = []
         5.times do |i|
             path = File.join(dest, i.to_s)
             returns << File.join(link.title, i.to_s)
             File.open(path, "w") { |f| f.puts "" }
         end
         assert_nothing_raised { ret = link.linkrecurse(true) }
 
         assert_equal(returns.sort, ret.collect { |f| f.title },
             "Did not get links back")
         
         returns.each do |path|
             obj = @file[path]
             assert(path, "did not get obj for %s" % path)
             sdest = File.join(dest, File.basename(path))
             assert_equal(sdest, obj.should(:target),
                 "target was not set correctly for %s" % path)
         end
     end
 
     def test_simplerecursivelinking
         source = tempfile()
         path = tempfile()
         subdir = File.join(source, "subdir")
         file = File.join(subdir, "file")
 
         system("mkdir -p %s" % subdir)
         system("touch %s" % file)
 
         link = nil
         assert_nothing_raised {
             link = Puppet.type(:file).create(
                 :ensure => source,
                 :path => path,
                 :recurse => true
             )
         }
 
         assert_apply(link)
 
         sublink = File.join(path, "subdir")
         linkpath = File.join(sublink, "file")
         assert(File.directory?(path), "dest is not a dir")
         assert(File.directory?(sublink), "subdest is not a dir")
         assert(File.symlink?(linkpath), "path is not a link")
         assert_equal(file, File.readlink(linkpath))
 
         assert_nil(@file[sublink], "objects were not removed")
         assert_events([], link)
     end
 
     def test_recursivelinking
         source = tempfile()
         dest = tempfile()
 
         files = []
         dirs = []
 
         # Make a bunch of files and dirs
         Dir.mkdir(source)
         Dir.chdir(source) do
             system("mkdir -p %s" % "some/path/of/dirs")
             system("mkdir -p %s" % "other/path/of/dirs")
             system("touch %s" % "file")
             system("touch %s" % "other/file")
             system("touch %s" % "some/path/of/file")
             system("touch %s" % "some/path/of/dirs/file")
             system("touch %s" % "other/path/of/file")
 
             files = %x{find . -type f}.chomp.split(/\n/)
             dirs = %x{find . -type d}.chomp.split(/\n/).reject{|d| d =~ /^\.+$/ }
         end
 
         link = nil
         assert_nothing_raised {
             link = Puppet.type(:file).create(
                 :ensure => source,
                 :path => dest,
                 :recurse => true
             )
         }
 
         assert_apply(link)
 
         files.each do |f|
             f.sub!(/^\.#{File::SEPARATOR}/, '')
             path = File.join(dest, f)
             assert(FileTest.exists?(path), "Link %s was not created" % path)
             assert(FileTest.symlink?(path), "%s is not a link" % f)
             target = File.readlink(path)
             assert_equal(File.join(source, f), target)
         end
 
         dirs.each do |d|
             d.sub!(/^\.#{File::SEPARATOR}/, '')
             path = File.join(dest, d)
             assert(FileTest.exists?(path), "Dir %s was not created" % path)
             assert(FileTest.directory?(path), "%s is not a directory" % d)
         end
     end
 
     def test_localrelativelinks
         dir = tempfile()
         Dir.mkdir(dir)
         source = File.join(dir, "source")
         File.open(source, "w") { |f| f.puts "yay" }
         dest = File.join(dir, "link")
 
         link = nil
         assert_nothing_raised {
             link = Puppet.type(:file).create(
                 :path => dest,
                 :ensure => "source"
             )
         }
 
         assert_events([:link_created], link)
         assert(FileTest.symlink?(dest), "Did not create link")
         assert_equal("source", File.readlink(dest))
         assert_equal("yay\n", File.read(dest))
     end
 
     def test_recursivelinkingmissingtarget
         source = tempfile()
         dest = tempfile()
 
         objects = []
         objects << Puppet.type(:exec).create(
             :command => "mkdir %s; touch %s/file" % [source, source],
             :title => "yay",
             :path => ENV["PATH"]
         )
         objects << Puppet.type(:file).create(
             :ensure => source,
             :path => dest,
             :recurse => true,
             :require => objects[0]
         )
 
         assert_apply(*objects)
 
         link = File.join(dest, "file")
         assert(FileTest.symlink?(link), "Did not make link")
         assert_equal(File.join(source, "file"), File.readlink(link))
     end
 
     def test_backupmodes
         file = tempfile()
         newfile = tempfile()
 
         File.open(file, "w", 0411) { |f| f.puts "yayness" }
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet::Type.type(:file).create(
                 :path => file, :content => "rahness\n"
             )
         }
 
 #        user = group = nil
 #        if Process.uid == 0
 #            user = nonrootuser
 #            group = nonrootgroup
 #            obj[:owner] = user.name
 #            obj[:group] = group.name
 #            File.chown(user.uid, group.gid, file)
 #        end
 
         assert_apply(obj)
 
         backupfile = file + obj[:backup]
         @@tmpfiles << backupfile
         assert(FileTest.exists?(backupfile),
             "Backup file %s does not exist" % backupfile)
 
         assert_equal(0411, filemode(backupfile),
             "File mode is wrong for backupfile")
 
 #        if Process.uid == 0
 #            assert_equal(user.uid, File.stat(backupfile).uid)
 #            assert_equal(group.gid, File.stat(backupfile).gid)
 #        end
 
         bucket = "bucket"
         bpath = tempfile()
         Dir.mkdir(bpath)
         Puppet::Type.type(:filebucket).create(
             :title => bucket, :path => bpath
         )
 
         obj[:backup] = bucket
         obj[:content] = "New content"
         assert_apply(obj)
 
         bucketedpath = File.join(bpath, "18cc17fa3047fcc691fdf49c0a7f539a", "contents")
 
         assert_equal(0440, filemode(bucketedpath))
     end
 
     def test_largefilechanges
         source = tempfile()
         dest = tempfile()
 
         # Now make a large file
         File.open(source, "w") { |f|
             500.times { |i| f.puts "line %s" % i }
         }
 
         obj = Puppet::Type.type(:file).create(
             :title => dest, :source => source
         )
 
         assert_events([:file_created], obj)
 
         File.open(source, File::APPEND|File::WRONLY) { |f| f.puts "another line" }
 
         assert_events([:file_changed], obj)
 
         # Now modify the dest file
         File.open(dest, File::APPEND|File::WRONLY) { |f| f.puts "one more line" }
 
         assert_events([:file_changed, :file_changed], obj)
 
     end
 
     def test_replacefilewithlink
         path = tempfile()
         link = tempfile()
 
         File.open(path, "w") { |f| f.puts "yay" }
         File.open(link, "w") { |f| f.puts "a file" }
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :ensure => path,
                 :path => link
             )
         }
 
         assert_events([:link_created], file)
 
         assert(FileTest.symlink?(link), "Link was not created")
 
         assert_equal(path, File.readlink(link), "Link was created incorrectly")
     end
 
     def test_replacedirwithlink
         path = tempfile()
         link = tempfile()
 
         File.open(path, "w") { |f| f.puts "yay" }
         Dir.mkdir(link)
         File.open(File.join(link, "yay"), "w") do |f| f.puts "boo" end
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :ensure => path,
                 :path => link,
                 :backup => false
             )
         }
 
         # First run through without :force
         assert_events([], file)
 
         assert(FileTest.directory?(link), "Link replaced dir without force")
 
         assert_nothing_raised { file[:force] = true }
 
         assert_events([:link_created], file)
 
         assert(FileTest.symlink?(link), "Link was not created")
 
         assert_equal(path, File.readlink(link), "Link was created incorrectly")
     end
 
     def test_replace_links_with_files
         base = tempfile()
 
         Dir.mkdir(base)
 
         file = File.join(base, "file")
         link = File.join(base, "link")
         File.open(file, "w") { |f| f.puts "yayness" }
         File.symlink(file, link)
 
         obj = Puppet::Type.type(:file).create(
             :path => link,
             :ensure => "file"
         )
 
         assert_apply(obj)
 
         assert_equal("yayness\n", File.read(file),
             "Original file got changed")
         assert_equal("file", File.lstat(link).ftype, "File is still a link")
     end
 
     def test_no_erase_linkedto_files
         base = tempfile()
 
         Dir.mkdir(base)
 
         dirs = {}
         %w{other source target}.each do |d|
             dirs[d] = File.join(base, d)
             Dir.mkdir(dirs[d])
         end
 
         file = File.join(dirs["other"], "file")
         sourcefile = File.join(dirs["source"], "sourcefile")
         link = File.join(dirs["target"], "link")
 
         File.open(file, "w") { |f| f.puts "other" }
         File.open(sourcefile, "w") { |f| f.puts "source" }
         File.symlink(file, link)
 
         obj = Puppet::Type.type(:file).create(
             :path => dirs["target"],
             :ensure => "file",
             :source => dirs["source"],
             :recurse => true
         )
 
 
         trans = assert_events([:file_created, :file_created], obj)
 
         newfile = File.join(dirs["target"], "sourcefile")
 
         assert(File.exists?(newfile), "File did not get copied")
 
         assert_equal(File.read(sourcefile), File.read(newfile),
             "File did not get copied correctly.")
 
         assert_equal("other\n", File.read(file),
             "Original file got changed")
         assert_equal("file", File.lstat(link).ftype, "File is still a link")
     end
 
     def test_replace_links
         dest = tempfile()
         otherdest = tempfile()
         link = tempfile()
 
         File.open(dest, "w") { |f| f.puts "boo" }
         File.open(otherdest, "w") { |f| f.puts "yay" }
 
         obj = Puppet::Type.type(:file).create(
             :path => link,
             :ensure => otherdest
         )
 
 
         assert_apply(obj)
 
         assert_equal(otherdest, File.readlink(link), "Link did not get created")
 
         obj[:ensure] = dest
 
         assert_apply(obj)
 
         assert_equal(dest, File.readlink(link), "Link did not get changed")
     end
 
     def test_file_with_spaces
         dir = tempfile()
         Dir.mkdir(dir)
         source = File.join(dir, "file spaces")
         dest = File.join(dir, "another space")
 
         File.open(source, "w") { |f| f.puts :yay }
         obj = Puppet::Type.type(:file).create(
             :path => dest,
             :source => source
         )
         assert(obj, "Did not create file")
 
         assert_apply(obj)
 
         assert(FileTest.exists?(dest), "File did not get created")
     end
 
     def test_present_matches_anything
         path = tempfile()
 
         file = Puppet::Type.newfile(:path => path, :ensure => :present)
 
         file.retrieve
         assert(! file.insync?, "File incorrectly in sync")
 
         # Now make a file
         File.open(path, "w") { |f| f.puts "yay" }
 
         file.retrieve
         assert(file.insync?, "File not in sync")
 
         # Now make a directory
         File.unlink(path)
         Dir.mkdir(path)
 
         file.retrieve
         assert(file.insync?, "Directory not considered 'present'")
 
         Dir.rmdir(path)
 
         # Now make a link
         file[:links] = :manage
 
         otherfile = tempfile()
         File.symlink(otherfile, path)
 
         file.retrieve
         assert(file.insync?, "Symlink not considered 'present'")
         File.unlink(path)
 
         # Now set some content, and make sure it works
         file[:content] = "yayness"
 
         assert_apply(file)
 
         assert_equal("yayness", File.read(path), "Content did not get set correctly")
     end
 
     # Make sure unmanaged files are be purged.
     def test_purge
         sourcedir = tempfile()
         destdir = tempfile()
         Dir.mkdir(sourcedir)
         Dir.mkdir(destdir)
         sourcefile = File.join(sourcedir, "sourcefile")
         dsourcefile = File.join(destdir, "sourcefile")
         localfile = File.join(destdir, "localfile")
-        randfile = File.join(destdir, "random")
+        purgee = File.join(destdir, "to_be_purged")
         File.open(sourcefile, "w") { |f| f.puts "funtest" }
         # this file should get removed
-        File.open(randfile, "w") { |f| f.puts "footest" }
+        File.open(purgee, "w") { |f| f.puts "footest" }
 
-        lfobj = Puppet::Type.newfile(:path => localfile, :content => "rahtest")
+        lfobj = Puppet::Type.newfile(:title => "localfile", :path => localfile, :content => "rahtest")
         
 
-        destobj = Puppet::Type.newfile(:path => destdir,
+        destobj = Puppet::Type.newfile(:title => "destdir", :path => destdir,
                                     :source => sourcedir,
                                     :recurse => true)
 
-        assert_apply(lfobj, destobj)
+        puts "a"
+        comp = newcomp(lfobj, destobj)
+        # trans = comp.evaluate
+        assert_apply(comp)
+        # assert_nothing_raised { trans.evaluate }
+        puts "b"
+        # graph = trans.relgraph
+        # graph.to_jpg("/Users/luke/Desktop/pics", "purging")
 
         assert(FileTest.exists?(dsourcefile), "File did not get copied")
         assert(FileTest.exists?(localfile), "File did not get created")
-        assert(FileTest.exists?(randfile), "File got prematurely purged")
+        assert(FileTest.exists?(purgee), "File got prematurely purged")
 
         assert_nothing_raised { destobj[:purge] = true }
-        assert_apply(lfobj, destobj)
+        assert_apply(comp)
+        system("find %s" % destdir)
 
         assert(FileTest.exists?(dsourcefile), "File got purged")
         assert(FileTest.exists?(localfile), "File got purged")
-        assert(! FileTest.exists?(randfile), "File did not get purged")
+        assert(! FileTest.exists?(purgee), "File did not get purged")
     end
 
     # Testing #274.  Make sure target can be used without 'ensure'.
     def test_target_without_ensure
         source = tempfile()
         dest = tempfile()
         File.open(source, "w") { |f| f.puts "funtest" }
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet::Type.newfile(:path => dest, :target => source)
         }
 
         assert_apply(obj)
     end
 
     def test_autorequire_owner_and_group
         file = tempfile()
         comp = nil
         user = nil
         group =nil
         home = nil
         ogroup = nil
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestu",
                 :home => file,
                 :gid => "pptestg"
             )
             home = Puppet.type(:file).create(
                 :path => file,
                 :owner => "pptestu",
                 :group => "pptestg",
                 :ensure => "directory"
             )
             group = Puppet.type(:group).create(
                 :name => "pptestg"
             )
             comp = newcomp(user, group, home)
         }
         
         # Now make sure we get a relationship for each of these
         rels = nil
         assert_nothing_raised { rels = home.autorequire }
         assert(rels.detect { |e| e.source == user }, "owner was not autorequired")
         assert(rels.detect { |e| e.source == group }, "group was not autorequired")
     end
 
     # Testing #309 -- //my/file => /my/file
     def test_slash_deduplication
         ["/my/////file/for//testing", "//my/file/for/testing///",
             "/my/file/for/testing"].each do |path|
             file = nil
             assert_nothing_raised do
                 file = Puppet::Type.newfile(:path => path)
             end
 
             assert_equal("/my/file/for/testing", file.title)
             assert_equal(file, Puppet::Type.type(:file)["/my/file/for/testing"])
             Puppet::Type.type(:file).clear
         end
     end
 
     # Testing #304
     def test_links_to_directories
         link = tempfile()
         file = tempfile()
         dir = tempfile()
         Dir.mkdir(dir)
 
         bucket = Puppet::Type.newfilebucket :name => "main"
         File.symlink(dir, link)
         File.open(file, "w") { |f| f.puts "" }
         assert_equal(dir, File.readlink(link))
         obj = Puppet::Type.newfile :path => link, :ensure => :link,
             :target => file, :recurse => false, :backup => "main"
 
         assert_apply(obj)
 
         assert_equal(file, File.readlink(link))
     end
 
     # Testing #303
     def test_nobackups_with_links
         link = tempfile()
         new = tempfile()
 
         File.open(link, "w") { |f| f.puts "old" }
         File.open(new, "w") { |f| f.puts "new" }
         obj = Puppet::Type.newfile :path => link, :ensure => :link,
             :target => new, :recurse => true, :backup => false
 
         assert_nothing_raised do
             obj.handlebackup
         end
 
         bfile = [link, "puppet-bak"].join(".")
 
         assert(! FileTest.exists?(bfile), "Backed up when told not to")
 
         assert_apply(obj)
 
         assert(! FileTest.exists?(bfile), "Backed up when told not to")
     end
 
     # Make sure we consistently handle backups for all cases.
     def test_ensure_with_backups
         # We've got three file types, so make sure we can replace any type
         # with the other type and that backups are done correctly.
         types = [:file, :directory, :link]
 
         dir = tempfile()
         path = File.join(dir, "test")
         linkdest = tempfile()
         creators = {
             :file => proc { File.open(path, "w") { |f| f.puts "initial" } },
             :directory => proc { Dir.mkdir(path) },
             :link => proc { File.symlink(linkdest, path) }
         }
 
         bucket = Puppet::Type.newfilebucket :name => "main", :path => tempfile()
 
         obj = Puppet::Type.newfile :path => path, :force => true,
             :links => :manage
 
         Puppet[:trace] = true
         ["main", false].each do |backup|
             obj[:backup] = backup
             obj.finish
             types.each do |should|
                 types.each do |is|
                     # It makes no sense to replace a directory with a directory
                     # next if should == :directory and is == :directory
 
                     Dir.mkdir(dir)
 
                     # Make the thing
                     creators[is].call
 
                     obj[:ensure] = should
 
                     if should == :link
                         obj[:target] = linkdest
                     else
                         if obj.state(:target)
                             obj.delete(:target)
                         end
                     end
 
                     # First try just removing the initial data
                     assert_nothing_raised do
                         obj.remove_existing(should)
                     end
 
                     unless is == should
                         # Make sure the original is gone
                         assert(! FileTest.exists?(obj[:path]),
                             "remove_existing did not work: " +
                             "did not remove %s with %s" % [is, should])
                     end
                     FileUtils.rmtree(obj[:path])
 
                     # Now make it again
                     creators[is].call
 
                     state = obj.state(:ensure)
 
                     state.retrieve
                     unless state.insync?
                         assert_nothing_raised do
                             state.sync
                         end
                     end
                     FileUtils.rmtree(dir)
                 end
             end
         end
     end
 end
 
 # $Id$
diff --git a/test/types/type.rb b/test/types/type.rb
index ade0275b8..aa37f2a18 100755
--- a/test/types/type.rb
+++ b/test/types/type.rb
@@ -1,779 +1,779 @@
 #!/usr/bin/env ruby
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet/type'
 require 'puppettest'
 
 class TestType < Test::Unit::TestCase
 	include PuppetTest
     def test_typemethods
         Puppet::Type.eachtype { |type|
             name = nil
             assert_nothing_raised("Searching for name for %s caused failure" %
                 type.to_s) {
                     name = type.name
             }
 
             assert(name, "Could not find name for %s" % type.to_s)
 
             assert_equal(
                 type,
                 Puppet::Type.type(name),
                 "Failed to retrieve %s by name" % name
             )
 
             # Skip types with no parameters or valid states
             #unless ! type.parameters.empty? or ! type.validstates.empty?
             #    next
             #end
 
             assert_nothing_raised {
                 assert(
                     type.namevar,
                     "Failed to retrieve namevar for %s" % name
                 )
 
                 assert_not_nil(
                     type.states,
                     "States for %s are nil" % name
                 )
 
                 assert_not_nil(
                     type.validstates,
                     "Valid states for %s are nil" % name
                 )
             }
         }
     end
 
     def test_stringvssymbols
         file = nil
         path = tempfile()
         assert_nothing_raised() {
             system("rm -f %s" % path)
             file = Puppet.type(:file).create(
                 :path => path,
                 :ensure => "file",
                 :recurse => true,
                 :checksum => "md5"
             )
         }
         assert_nothing_raised() {
             file.retrieve
         }
         assert_nothing_raised() {
             file.evaluate
         }
         Puppet.type(:file).clear
         assert_nothing_raised() {
             system("rm -f %s" % path)
             file = Puppet.type(:file).create(
                 "path" => path,
                 "ensure" => "file",
                 "recurse" => true,
                 "checksum" => "md5"
             )
         }
         assert_nothing_raised() {
             file.retrieve
         }
         assert_nothing_raised() {
             file[:path]
         }
         assert_nothing_raised() {
             file["path"]
         }
         assert_nothing_raised() {
             file[:recurse]
         }
         assert_nothing_raised() {
             file["recurse"]
         }
         assert_nothing_raised() {
             file.evaluate
         }
     end
 
     # This was supposed to test objects whose name was a state, but that
     # fundamentally doesn't make much sense, and we now don't have any such
     # types.
     def disabled_test_nameasstate
         # currently groups are the only objects with the namevar as a state
         group = nil
         assert_nothing_raised {
             group = Puppet.type(:group).create(
                 :name => "testing"
             )
         }
 
         assert_equal("testing", group.name, "Could not retrieve name")
     end
 
     # Verify that values get merged correctly
     def test_mergestatevalues
         file = tempfile()
 
         # Create the first version
         assert_nothing_raised {
             Puppet.type(:file).create(
                 :path => file,
                 :owner => ["root", "bin"]
             )
         }
 
         # Make sure no other statements are allowed
         assert_raise(Puppet::Error) {
             Puppet.type(:file).create(
                 :path => file,
                 :group => "root"
             )
         }
     end
 
     # Verify that aliasing works
     def test_aliasing
         file = tempfile()
 
         baseobj = nil
         assert_nothing_raised {
             baseobj = Puppet.type(:file).create(
                 :name => file,
                 :ensure => "file",
                 :alias => ["funtest"]
             )
         }
 
         # Verify our adding ourselves as an alias isn't an error.
         assert_nothing_raised {
             baseobj[:alias] = file
         }
 
         assert_instance_of(Puppet.type(:file), Puppet.type(:file)["funtest"],
             "Could not retrieve alias")
 
     end
 
     # Verify that requirements don't depend on file order
     def test_prereqorder
         one = tempfile()
         two = tempfile()
 
         twoobj = nil
         oneobj = nil
         assert_nothing_raised("Could not create prereq that doesn't exist yet") {
             twoobj = Puppet.type(:file).create(
                 :name => two,
                 :require => [:file, one]
             )
         }
 
         assert_nothing_raised {
             oneobj = Puppet.type(:file).create(
                 :name => one
             )
         }
 
         comp = newcomp(twoobj, oneobj)
 
         assert_nothing_raised {
             comp.finalize
         }
 
 
         assert(twoobj.requires?(oneobj), "Requirement was not created")
     end
 
     # Verify that names are aliases, not equivalents
     def test_nameasalias
         file = nil
         # Create the parent dir, so we make sure autorequiring the parent dir works
         parentdir = tempfile()
         dir = Puppet.type(:file).create(
             :name => parentdir,
             :ensure => "directory"
         )
         assert_apply(dir)
         path = File.join(parentdir, "subdir")
         name = "a test file"
         transport = Puppet::TransObject.new(name, "file")
         transport[:path] = path
         transport[:ensure] = "file"
         assert_nothing_raised {
             file = transport.to_type
         }
 
         assert_equal(path, file[:path])
         assert_equal(name, file.title)
 
         assert_nothing_raised {
             file.retrieve
         }
 
         assert_apply(file)
 
         assert(Puppet.type(:file)[name], "Could not look up object by name")
     end
 
     def test_ensuredefault
         user = nil
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestAA",
                 :check => [:uid]
             )
         }
 
         # make sure we don't get :ensure for unmanaged files
         assert(! user.state(:ensure), "User got an ensure state")
 
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestAA",
                 :comment => "Testingness"
             )
         }
         # but make sure it gets added once we manage them
         assert(user.state(:ensure), "User did not add ensure state")
 
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestBB",
                 :comment => "A fake user"
             )
         }
 
         # and make sure managed objects start with them
         assert(user.state(:ensure), "User did not get an ensure state")
     end
 
     # Make sure removal works
     def test_remove
         objects = {}
         top = Puppet.type(:component).create(:name => "top")
         objects[top.class] = top
 
         base = tempfile()
 
         # now make a two-tier, 5 piece tree
         %w{a b}.each do |letter|
             name = "comp%s" % letter
             comp = Puppet.type(:component).create(:name => name)
             top.push comp
             objects[comp.class] = comp
 
             5.times do |i|
                 file = base + letter + i.to_s
 
                 obj = Puppet.type(:file).create(:name => file, :ensure => "file")
 
                 comp.push obj
                 objects[obj.class] = obj
             end
         end
 
         assert_nothing_raised do
             top.remove
         end
 
         objects.each do |klass, obj|
             assert_nil(klass[obj.name], "object %s was not removed" % obj.name)
         end
     end
 
     # Verify that objects can't be their own children.
     def test_object_recursion
         comp = Puppet.type(:component).create(:name => "top")
 
         file = Puppet.type(:file).create(:path => tempfile, :ensure => :file)
 
         assert_raise(Puppet::DevError) do
             comp.push(comp)
         end
 
         assert_raise(Puppet::DevError) do
             file.push(file)
         end
 
         assert_raise(Puppet::DevError) do
             comp.parent = comp
         end
 
         assert_raise(Puppet::DevError) do
             file.parent = file
         end
 
         assert_nothing_raised {
             comp.push(file)
         }
 
         assert_raise(Puppet::DevError) do
             file.push(comp)
         end
 
         assert_raise(Puppet::DevError) do
             comp.parent = file
         end
     end
 
     def test_loadplugins
         names = %w{loadedplugin1 loadplugin2 loadplugin3}
         dirs = []
         3.times { dirs << tempfile() }
         # Set plugindest to something random
         Puppet[:plugindest] = tempfile()
 
         Puppet[:pluginpath] = dirs.join(":")
 
         names.each do |name|
             dir = dirs.shift
             Dir.mkdir(dir)
 
             # Create an extra file for later
             [name, name + "2ness"].each do |n|
                 file = File.join(dir, n + ".rb")
                 File.open(file, "w") do |f|
                     f.puts %{Puppet::Type.newtype('#{n}') do
     newparam(:argument) do
         isnamevar
     end
 end
 }
                 end
             end
 
             assert(Puppet::Type.type(name),
                 "Did not get loaded plugin")
 
             assert_nothing_raised {
                 Puppet::Type.type(name).create(
                     :name => "myname"
                 )
             }
         end
 
         # Now make sure the plugindest got added to our pluginpath
         assert(Puppet[:pluginpath].split(":").include?(Puppet[:plugindest]),
             "Plugin dest did not get added to plugin path")
 
         # Now make sure it works with just a single path, using the extra files
         # created above.
         Puppet[:pluginpath] = Puppet[:pluginpath].split(":")[0]
         assert(Puppet::Type.type("loadedplugin12ness"),
             "Did not get loaded plugin")
 
     end
 
     def test_newtype_methods
         assert_nothing_raised {
             Puppet::Type.newtype(:mytype) do
                 newparam(:wow) do isnamevar end
             end
         }
 
         assert(Puppet::Type.respond_to?(:newmytype),
             "new<type> method did not get created")
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet::Type.newmytype(:wow => "yay")
         }
 
         assert(obj.is_a?(Puppet::Type.type(:mytype)),
             "Obj is not the correct type")
 
         # Now make the type again, just to make sure it works on refreshing.
         assert_nothing_raised {
             Puppet::Type.newtype(:mytype) do
                 newparam(:yay) do isnamevar end
             end
         }
 
         obj = nil
         # Make sure the old class was thrown away and only the new one is sitting
         # around.
         assert_raise(Puppet::Error) {
             obj = Puppet::Type.newmytype(:wow => "yay")
         }
         assert_nothing_raised {
             obj = Puppet::Type.newmytype(:yay => "yay")
         }
 
         # Now make sure that we don't replace existing, non-type methods
         parammethod = Puppet::Type.method(:newparam)
 
         assert_nothing_raised {
             Puppet::Type.newtype(:param) do
                 newparam(:rah) do isnamevar end
             end
         }
         assert_equal(parammethod, Puppet::Type.method(:newparam),
             "newparam method got replaced by newtype")
     end
 
     def test_newstate_options
         # Create a type with a fake provider
         providerclass = Class.new do
             def method_missing(method, *args)
                 return method
             end
         end
         self.class.const_set("ProviderClass", providerclass)
 
         type = Puppet::Type.newtype(:mytype) do
             newparam(:name) do
                 isnamevar
             end
             def provider
                 @provider ||= ProviderClass.new
 
                 @provider
             end
         end
 
         # Now make a state with no options.
         state = nil
         assert_nothing_raised do
             state = type.newstate(:noopts) do
             end
         end
 
         # Now create an instance
         obj = type.create(:name => :myobj)
 
         inst = state.new(:parent => obj)
 
         # And make sure it's correctly setting @is
         ret = nil
         assert_nothing_raised {
             ret = inst.retrieve
         }
 
         assert_equal(:noopts, inst.is)
 
         # Now create a state with a different way of doing it
         state = nil
         assert_nothing_raised do
             state = type.newstate(:setretrieve, :retrieve => :yayness)
         end
 
         inst = state.new(:parent => obj)
 
         # And make sure it's correctly setting @is
         ret = nil
         assert_nothing_raised {
             ret = inst.retrieve
         }
 
         assert_equal(:yayness, inst.is)
     end
 
     def test_name_vs_title
         path = tempfile()
 
         trans = nil
 
         assert_nothing_raised {
             trans = Puppet::TransObject.new(path, :file)
         }
 
         file = nil
         assert_nothing_raised {
             file = Puppet::Type.newfile(trans)
         }
 
         assert(file.respond_to?(:title),
             "No 'title' method")
 
         assert(file.respond_to?(:name),
             "No 'name' method")
 
         assert_equal(file.title, file.name,
             "Name and title were not marked equal")
 
         assert_nothing_raised {
             file.title = "My file"
         }
 
         assert_equal("My file", file.title)
         assert_equal(path, file.name)
     end
 
     # Make sure the title is sufficiently differentiated from the namevar.
     def test_title_at_creation_with_hash
         file = nil
         fileclass = Puppet::Type.type(:file) 
 
         path = tempfile()
         assert_nothing_raised do
             file = fileclass.create(
                 :title => "Myfile",
                 :path => path
             )
         end
 
         assert_equal("Myfile", file.title, "Did not get correct title")
         assert_equal(path, file[:name], "Did not get correct name")
 
         file = nil
         Puppet::Type.type(:file).clear
 
         # Now make sure we can specify both and still get the right answers
         assert_nothing_raised do
             file = fileclass.create(
                 :title => "Myfile",
                 :name => path
             )
         end
 
         assert_instance_of(fileclass, file)
 
         assert_equal("Myfile", file.title, "Did not get correct title")
         assert_equal(path, file[:name], "Did not get correct name")
     end
 
     # Make sure the "create" class method behaves appropriately.
     def test_class_create
         title = "Myfile"
         validate = proc do |element|
             assert(element, "Did not create file")
             assert_instance_of(Puppet::Type.type(:file), element)
             assert_equal(title, element.title, "Title is not correct")
         end
         type = :file
         args = {:path => tempfile(), :owner => "root"}
 
         trans = Puppet::TransObject.new(title, type)
         args.each do |name, val| trans[name] = val end
 
         # First call it on the appropriate typeclass
         obj = nil
         assert_nothing_raised do
             obj = Puppet::Type.type(:file).create(trans)
         end
 
         validate.call(obj)
 
         # Now try it using the class method on Type
         oldid = obj.object_id
         obj = nil
         Puppet::Type.type(:file).clear
 
         assert_nothing_raised {
             obj = Puppet::Type.create(trans)
         }
 
         validate.call(obj)
         assert(oldid != obj.object_id, "Got same object back")
 
         # Now try the same things with hashes instead of a transobject
         oldid = obj.object_id
         obj = nil
         Puppet::Type.type(:file).clear
         hash = {
             :type => :file,
             :title => "Myfile",
             :path => tempfile(),
             :owner => "root"
         }
 
         # First call it on the appropriate typeclass
         obj = nil
         assert_nothing_raised do
             obj = Puppet::Type.type(:file).create(hash)
         end
 
         validate.call(obj)
         assert_equal(:file, obj.should(:type),
             "Type param did not pass through")
 
         assert(oldid != obj.object_id, "Got same object back")
 
         # Now try it using the class method on Type
         oldid = obj.object_id
         obj = nil
         Puppet::Type.type(:file).clear
 
         assert_nothing_raised {
             obj = Puppet::Type.create(hash)
         }
 
         validate.call(obj)
         assert(oldid != obj.object_id, "Got same object back")
         assert_nil(obj.should(:type),
             "Type param passed through")
     end
 
     def test_multiplenames
         obj = nil
         path = tempfile()
         assert_raise ArgumentError do
             obj = Puppet::Type.type(:file).create(
                 :name => path,
                 :path => path
             )
         end
     end
 
     def test_title_and_name
         obj = nil
         path = tempfile()
         fileobj = Puppet::Type.type(:file)
 
         assert_nothing_raised do
             obj = fileobj.create(
                 :title => "myfile",
                 :path => path
             )
         end
 
         assert_equal(obj, fileobj["myfile"],
             "Could not retrieve obj by title")
 
         assert_equal(obj, fileobj[path],
             "Could not retrieve obj by name")
     end
 
     # Make sure default providers behave correctly
     def test_defaultproviders
         # Make a fake type
         type = Puppet::Type.newtype(:defaultprovidertest) do
             newparam(:name) do end
         end
 
         basic = type.provide(:basic) do
             defaultfor :operatingsystem => :somethingelse,
                 :operatingsystemrelease => :yayness
         end
 
         assert_equal(basic, type.defaultprovider)
         type.defaultprovider = nil
 
         greater = type.provide(:greater) do
             defaultfor :operatingsystem => Facter.value("operatingsystem")
         end
 
         assert_equal(greater, type.defaultprovider)
     end
 
     # Make sure that we can have multiple isomorphic objects with the same name,
     # but not with non-isomorphic objects.
     def test_isomorphic_names
         # First do execs, since they're not isomorphic.
         echo = Puppet::Util.binary "echo"
         exec1 = exec2 = nil
         assert_nothing_raised do
             exec1 = Puppet::Type.type(:exec).create(
                 :title => "exec1",
                 :command => "#{echo} funtest"
             )
         end
         assert_nothing_raised do
             exec2 = Puppet::Type.type(:exec).create(
                 :title => "exec2",
                 :command => "#{echo} funtest"
             )
         end
 
         assert_apply(exec1, exec2)
 
         # Now do files, since they are. This should fail.
         file1 = file2 = nil
         path = tempfile()
         assert_nothing_raised do
             file1 = Puppet::Type.type(:file).create(
                 :title => "file1",
                 :path => path,
                 :content => "yayness"
             )
         end
 
         # This will fail, but earlier systems will catch it.
         assert_raise(Puppet::Error) do
             file2 = Puppet::Type.type(:file).create(
                 :title => "file2",
                 :path => path,
                 :content => "rahness"
             )
         end
 
         assert(file1, "Did not create first file")
         assert_nil(file2, "Incorrectly created second file")
     end
 
     def test_tags
         obj = Puppet::Type.type(:file).create(:path => tempfile())
 
         tags = [:some, :test, :tags]
 
         obj.tags = tags
 
         assert_equal(tags + [:file], obj.tags)
     end
 
     def disabled_test_list
         Puppet::Type.loadall
 
         Puppet::Type.eachtype do |type|
             next if type.name == :symlink
             next if type.name == :component
             next if type.name == :tidy
             assert(type.respond_to?(:list), "%s does not respond to list" % type.name)
         end
     end
 
     def test_to_hash
         file = Puppet::Type.newfile :path => tempfile(), :owner => "luke",
             :recurse => true, :loglevel => "warning"
 
         hash = nil
         assert_nothing_raised do
             hash = file.to_hash
         end
 
         [:path, :owner, :recurse, :loglevel].each do |param|
             assert(hash[param], "Hash did not include %s" % param)
         end
     end
 
     # Make sure that classes behave like hashes.
     def test_class_hash_behaviour
         path = tempfile()
 
         filetype = Puppet::Type.type(:file)
         one = Puppet::Type.newfile :path => path
 
         assert_equal(one, filetype[path], "Did not get file back")
 
         assert_raise(Puppet::Error) do
             filetype[path] = one
         end
     end
 
     def test_ref
         path = tempfile()
         file = Puppet::Type.newfile(:path => path)
-        assert_equal("file[#{path}]", file.ref)
+        assert_equal("File[#{path}]", file.ref)
 
         exec = Puppet::Type.newexec(:title => "yay", :command => "/bin/echo yay")
         assert_equal("exec[yay]", exec.ref)
     end
     
     def test_noop_metaparam
         file = Puppet::Type.newfile :path => tempfile
         assert(!file.noop, "file incorrectly in noop")
         
         assert_nothing_raised do
             file[:noop] = true
         end
         assert(file.noop, "file should be in noop")
         
         # Now set the main one
         Puppet[:noop] = true
         assert(file.noop, "file should be in noop")
         file[:noop] = false
         assert(file.noop, "file should be in noop")
     end
 end
 
 # $Id$