diff --git a/lib/puppet/reports/tagmail.rb b/lib/puppet/reports/tagmail.rb
index 0eeb4b72b..d4320d63f 100644
--- a/lib/puppet/reports/tagmail.rb
+++ b/lib/puppet/reports/tagmail.rb
@@ -1,179 +1,179 @@
 require 'puppet'
 require 'pp'
 
 require 'net/smtp'
 require 'time'
 
 Puppet::Reports.register_report(:tagmail) do
   desc "This report sends specific log messages to specific email addresses
     based on the tags in the log messages.  
 
     See the [documentation on tags](http://projects.puppetlabs.com/projects/puppet/wiki/Using_Tags) for more information.
 
     To use this report, you must create a `tagmail.conf` file in the location
     specified by the `tagmap` setting.  This is a simple file that maps tags to
     email addresses:  Any log messages in the report that match the specified
     tags will be sent to the specified email addresses.
 
     Lines in the `tagmail.conf` file consist of a comma-separated list
     of tags, a colon, and a comma-separated list of email addresses.
     Tags can be !negated with a leading exclamation mark, which will
     subtract any messages with that tag from the set of events handled
     by that line.
 
     Puppet's log levels (`debug`, `info`, `notice`, `warning`, `err`,
     `alert`, `emerg`, `crit`, and `verbose`) can also be used as tags,
     and there is an `all` tag that will always match all log messages.
 
     An example `tagmail.conf`:
 
         all: me@domain.com
         webserver, !mailserver: httpadmins@domain.com
 
     This will send all messages to `me@domain.com`, and all messages from
     webservers that are not also from mailservers to `httpadmins@domain.com`.
 
     If you are using anti-spam controls such as grey-listing on your mail
     server, you should whitelist the sending email address (controlled by
     `reportform` configuration option) to ensure your email is not discarded as spam.
     "
 
   # Find all matching messages.
   def match(taglists)
     matching_logs = []
     taglists.each do |emails, pos, neg|
       # First find all of the messages matched by our positive tags
       messages = nil
       if pos.include?("all")
         messages = self.logs
       else
         # Find all of the messages that are tagged with any of our
         # tags.
         messages = self.logs.find_all do |log|
           pos.detect { |tag| log.tagged?(tag) }
         end
       end
 
       # Now go through and remove any messages that match our negative tags
       messages = messages.reject do |log|
         true if neg.detect do |tag| log.tagged?(tag) end
       end
 
       if messages.empty?
         Puppet.info "No messages to report to #{emails.join(",")}"
         next
       else
         matching_logs << [emails, messages.collect { |m| m.to_report }.join("\n")]
       end
     end
 
     matching_logs
   end
 
   # Load the config file
   def parse(text)
     taglists = []
     text.split("\n").each do |line|
       taglist = emails = nil
       case line.chomp
       when /^\s*#/; next
       when /^\s*$/; next
       when /^\s*(.+)\s*:\s*(.+)\s*$/
         taglist = $1
         emails = $2.sub(/#.*$/,'')
       else
         raise ArgumentError, "Invalid tagmail config file"
       end
 
       pos = []
       neg = []
       taglist.sub(/\s+$/,'').split(/\s*,\s*/).each do |tag|
         unless tag =~ /^!?[-\w\.]+$/
           raise ArgumentError, "Invalid tag #{tag.inspect}"
         end
         case tag
         when /^\w+/; pos << tag
         when /^!\w+/; neg << tag.sub("!", '')
         else
           raise Puppet::Error, "Invalid tag '#{tag}'"
         end
       end
 
       # Now split the emails
       emails = emails.sub(/\s+$/,'').split(/\s*,\s*/)
       taglists << [emails, pos, neg]
     end
     taglists
   end
 
   # Process the report.  This just calls the other associated messages.
   def process
     unless FileTest.exists?(Puppet[:tagmap])
       Puppet.notice "Cannot send tagmail report; no tagmap file #{Puppet[:tagmap]}"
       return
     end
 
     metrics = raw_summary['resources'] || {} rescue {}
 
     if metrics['out_of_sync'] == 0 && metrics['changed'] == 0
       Puppet.notice "Not sending tagmail report; no changes"
       return
     end
 
     taglists = parse(File.read(Puppet[:tagmap]))
 
     # Now find any appropriately tagged messages.
     reports = match(taglists)
 
-    send(reports)
+    send(reports) unless reports.empty?
   end
 
   # Send the email reports.
   def send(reports)
     pid = Puppet::Util.safe_posix_fork do
       if Puppet[:smtpserver] != "none"
         begin
           Net::SMTP.start(Puppet[:smtpserver]) do |smtp|
             reports.each do |emails, messages|
               smtp.open_message_stream(Puppet[:reportfrom], *emails) do |p|
                 p.puts "From: #{Puppet[:reportfrom]}"
                 p.puts "Subject: Puppet Report for #{self.host}"
                 p.puts "To: " + emails.join(", ")
                 p.puts "Date: #{Time.now.rfc2822}"
                 p.puts
                 p.puts messages
               end
             end
           end
         rescue => detail
           message = "Could not send report emails through smtp: #{detail}"
           Puppet.log_exception(detail, message)
           raise Puppet::Error, message
         end
       elsif Puppet[:sendmail] != ""
         begin
           reports.each do |emails, messages|
             # We need to open a separate process for every set of email addresses
             IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
               p.puts "From: #{Puppet[:reportfrom]}"
               p.puts "Subject: Puppet Report for #{self.host}"
               p.puts "To: " + emails.join(", ")
 
               p.puts messages
             end
           end
         rescue => detail
           message = "Could not send report emails via sendmail: #{detail}"
           Puppet.log_exception(detail, message)
           raise Puppet::Error, message
         end
       else
         raise Puppet::Error, "SMTP server is unset and could not find sendmail"
       end
     end
 
     # Don't bother waiting for the pid to return.
     Process.detach(pid)
   end
 end
 
diff --git a/lib/puppet/type/cron.rb b/lib/puppet/type/cron.rb
index 40f9fe81d..a742a17ff 100755
--- a/lib/puppet/type/cron.rb
+++ b/lib/puppet/type/cron.rb
@@ -1,416 +1,421 @@
 require 'etc'
 require 'facter'
 require 'puppet/util/filetype'
 
 Puppet::Type.newtype(:cron) do
   @doc = <<-EOT
     Installs and manages cron jobs.  Every cron resource requires a command
     and user attribute, as well as at least one periodic attribute (hour,
     minute, month, monthday, weekday, or special).  While the name of the cron
     job is not part of the actual job, it is used by Puppet to store and
     retrieve it.
 
     If you specify a cron job that matches an existing job in every way
     except name, then the jobs will be considered equivalent and the
     new name will be permanently associated with that job.  Once this
     association is made and synced to disk, you can then manage the job
     normally (e.g., change the schedule of the job).
 
     Example:
 
         cron { logrotate:
           command => "/usr/sbin/logrotate",
           user    => root,
           hour    => 2,
           minute  => 0
         }
 
     Note that all periodic attributes can be specified as an array of values:
 
         cron { logrotate:
           command => "/usr/sbin/logrotate",
           user    => root,
           hour    => [2, 4]
         }
 
     ...or using ranges or the step syntax `*/2` (although there's no guarantee
     that your `cron` daemon supports these):
 
         cron { logrotate:
           command => "/usr/sbin/logrotate",
           user    => root,
           hour    => ['2-4'],
           minute  => '*/10'
         }
   EOT
   ensurable
 
   # A base class for all of the Cron parameters, since they all have
   # similar argument checking going on.
   class CronParam < Puppet::Property
     class << self
       attr_accessor :boundaries, :default
     end
 
     # We have to override the parent method, because we consume the entire
     # "should" array
     def insync?(is)
       self.is_to_s(is) == self.should_to_s
     end
 
     # A method used to do parameter input handling.  Converts integers
     # in string form to actual integers, and returns the value if it's
     # an integer or false if it's just a normal string.
     def numfix(num)
       if num =~ /^\d+$/
         return num.to_i
       elsif num.is_a?(Integer)
         return num
       else
         return false
       end
     end
 
     # Verify that a number is within the specified limits.  Return the
     # number if it is, or false if it is not.
     def limitcheck(num, lower, upper)
       (num >= lower and num <= upper) && num
     end
 
     # Verify that a value falls within the specified array.  Does case
     # insensitive matching, and supports matching either the entire word
     # or the first three letters of the word.
     def alphacheck(value, ary)
       tmp = value.downcase
 
       # If they specified a shortened version of the name, then see
       # if we can lengthen it (e.g., mon => monday).
       if tmp.length == 3
         ary.each_with_index { |name, index|
           if tmp.upcase == name[0..2].upcase
             return index
           end
         }
       else
         return ary.index(tmp) if ary.include?(tmp)
       end
 
       false
     end
 
     def should_to_s(newvalue = @should)
       if newvalue
         newvalue = [newvalue] unless newvalue.is_a?(Array)
         if self.name == :command or newvalue[0].is_a? Symbol
           newvalue[0]
         else
           newvalue.join(",")
         end
       else
         nil
       end
     end
 
     def is_to_s(currentvalue = @is)
       if currentvalue
         return currentvalue unless currentvalue.is_a?(Array)
 
         if self.name == :command or currentvalue[0].is_a? Symbol
           currentvalue[0]
         else
           currentvalue.join(",")
         end
       else
         nil
       end
     end
 
     def should
       if @should and @should[0] == :absent
         :absent
       else
         @should
       end
     end
 
     def should=(ary)
       super
       @should.flatten!
     end
 
     # The method that does all of the actual parameter value
     # checking; called by all of the +param<name>=+ methods.
     # Requires the value, type, and bounds, and optionally supports
     # a boolean of whether to do alpha checking, and if so requires
     # the ary against which to do the checking.
     munge do |value|
       # Support 'absent' as a value, so that they can remove
       # a value
       if value == "absent" or value == :absent
         return :absent
       end
 
       # Allow the */2 syntax
       if value =~ /^\*\/[0-9]+$/
         return value
       end
 
       # Allow ranges
       if value =~ /^[0-9]+-[0-9]+$/
         return value
       end
 
       # Allow ranges + */2
       if value =~ /^[0-9]+-[0-9]+\/[0-9]+$/
         return value
       end
 
       if value == "*"
         return :absent
       end
 
       return value unless self.class.boundaries
       lower, upper = self.class.boundaries
       retval = nil
       if num = numfix(value)
         retval = limitcheck(num, lower, upper)
       elsif respond_to?(:alpha)
         # If it has an alpha method defined, then we check
         # to see if our value is in that list and if so we turn
         # it into a number
         retval = alphacheck(value, alpha)
       end
 
       if retval
         return retval.to_s
       else
         self.fail "#{value} is not a valid #{self.class.name}"
       end
     end
   end
 
   # Somewhat uniquely, this property does not actually change anything -- it
   # just calls +@resource.sync+, which writes out the whole cron tab for
   # the user in question.  There is no real way to change individual cron
   # jobs without rewriting the entire cron file.
   #
   # Note that this means that managing many cron jobs for a given user
   # could currently result in multiple write sessions for that user.
   newproperty(:command, :parent => CronParam) do
     desc "The command to execute in the cron job.  The environment
       provided to the command varies by local system rules, and it is
       best to always provide a fully qualified command.  The user's
       profile is not sourced when the command is run, so if the
       user's environment is desired it should be sourced manually.
 
       All cron parameters support `absent` as a value; this will
       remove any existing values for that field."
 
     def retrieve
       return_value = super
       return_value = return_value[0] if return_value && return_value.is_a?(Array)
 
       return_value
     end
 
     def should
       if @should
         if @should.is_a? Array
           @should[0]
         else
           devfail "command is not an array"
         end
       else
         nil
       end
     end
   end
 
   newproperty(:special) do
     desc "A special value such as 'reboot' or 'annually'.
        Only available on supported systems such as Vixie Cron.
        Overrides more specific time of day/week settings."
 
     def specials
       %w{reboot yearly annually monthly weekly daily midnight hourly}
     end
 
     validate do |value|
       raise ArgumentError, "Invalid special schedule #{value.inspect}" unless specials.include?(value)
     end
   end
 
   newproperty(:minute, :parent => CronParam) do
     self.boundaries = [0, 59]
     desc "The minute at which to run the cron job.
       Optional; if specified, must be between 0 and 59, inclusive."
   end
 
   newproperty(:hour, :parent => CronParam) do
     self.boundaries = [0, 23]
     desc "The hour at which to run the cron job. Optional;
       if specified, must be between 0 and 23, inclusive."
   end
 
   newproperty(:weekday, :parent => CronParam) do
     def alpha
       %w{sunday monday tuesday wednesday thursday friday saturday}
     end
     self.boundaries = [0, 7]
     desc "The weekday on which to run the command.
       Optional; if specified, must be between 0 and 7, inclusive, with
       0 (or 7) being Sunday, or must be the name of the day (e.g., Tuesday)."
   end
 
   newproperty(:month, :parent => CronParam) do
     def alpha
       %w{january february march april may june july
         august september october november december}
     end
     self.boundaries = [1, 12]
     desc "The month of the year.  Optional; if specified
       must be between 1 and 12 or the month name (e.g., December)."
   end
 
   newproperty(:monthday, :parent => CronParam) do
     self.boundaries = [1, 31]
     desc "The day of the month on which to run the
       command.  Optional; if specified, must be between 1 and 31."
   end
 
   newproperty(:environment) do
     desc "Any environment settings associated with this cron job.  They
       will be stored between the header and the job in the crontab.  There
       can be no guarantees that other, earlier settings will not also
       affect a given cron job.
 
 
       Also, Puppet cannot automatically determine whether an existing,
       unmanaged environment setting is associated with a given cron
       job.  If you already have cron jobs with environment settings,
       then Puppet will keep those settings in the same place in the file,
       but will not associate them with a specific job.
 
       Settings should be specified exactly as they should appear in
       the crontab, e.g., `PATH=/bin:/usr/bin:/usr/sbin`."
 
     validate do |value|
       unless value =~ /^\s*(\w+)\s*=\s*(.*)\s*$/ or value == :absent or value == "absent"
         raise ArgumentError, "Invalid environment setting #{value.inspect}"
       end
     end
 
     def insync?(is)
       if is.is_a? Array
         return is.sort == @should.sort
       else
         return is == @should
       end
     end
 
     def is_to_s(newvalue)
       if newvalue
         if newvalue.is_a?(Array)
           newvalue.join(",")
         else
           newvalue
         end
       else
         nil
       end
     end
 
     def should
       @should
     end
 
     def should_to_s(newvalue = @should)
       if newvalue
         newvalue.join(",")
       else
         nil
       end
     end
   end
 
   newparam(:name) do
     desc "The symbolic name of the cron job.  This name
       is used for human reference only and is generated automatically
       for cron jobs found on the system.  This generally won't
       matter, as Puppet will do its best to match existing cron jobs
       against specified jobs (and Puppet adds a comment to cron jobs it adds),
       but it is at least possible that converting from unmanaged jobs to
       managed jobs might require manual intervention."
 
     isnamevar
   end
 
   newproperty(:user) do
     desc "The user to run the command as.  This user must
       be allowed to run cron jobs, which is not currently checked by
       Puppet.
 
       The user defaults to whomever Puppet is running as."
 
     defaultto {
       struct = Etc.getpwuid(Process.uid)
       struct.respond_to?(:name) && struct.name or 'root'
     }
   end
 
+  # Autorequire the owner of the crontab entry.
+  autorequire(:user) do
+    self[:user]
+  end
+
   newproperty(:target) do
     desc "Where the cron job should be stored.  For crontab-style
       entries this is the same as the user and defaults that way.
       Other providers default accordingly."
 
     defaultto {
       if provider.is_a?(@resource.class.provider(:crontab))
         if val = @resource.should(:user)
           val
         else
           raise ArgumentError,
             "You must provide a user with crontab entries"
         end
       elsif provider.class.ancestors.include?(Puppet::Provider::ParsedFile)
         provider.class.default_target
       else
         nil
       end
     }
   end
 
   # We have to reorder things so that :provide is before :target
 
   attr_accessor :uid
 
   def value(name)
     name = symbolize(name)
     ret = nil
     if obj = @parameters[name]
       ret = obj.should
 
       ret ||= obj.retrieve
 
       if ret == :absent
         ret = nil
       end
     end
 
     unless ret
       case name
       when :command
         devfail "No command, somehow" unless @parameters[:ensure].value == :absent
       when :special
         # nothing
       else
         #ret = (self.class.validproperty?(name).default || "*").to_s
         ret = "*"
       end
     end
 
     ret
   end
 end
 
 
 
diff --git a/spec/unit/reports/tagmail_spec.rb b/spec/unit/reports/tagmail_spec.rb
index 00f78c932..7fd209828 100755
--- a/spec/unit/reports/tagmail_spec.rb
+++ b/spec/unit/reports/tagmail_spec.rb
@@ -1,168 +1,218 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/reports'
 
 tagmail = Puppet::Reports.report(:tagmail)
 
 describe tagmail do
   before do
     @processor = Puppet::Transaction::Report.new("apply")
     @processor.extend(Puppet::Reports.report(:tagmail))
   end
 
   passers = my_fixture "tagmail_passers.conf"
   File.readlines(passers).each do |line|
     it "should be able to parse '#{line.inspect}'" do
       @processor.parse(line)
     end
   end
 
   failers = my_fixture "tagmail_failers.conf"
   File.readlines(failers).each do |line|
     it "should not be able to parse '#{line.inspect}'" do
       lambda { @processor.parse(line) }.should raise_error(ArgumentError)
     end
   end
 
   {
     "tag: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag}, []],
     "tag.localhost: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag.localhost}, []],
     "tag, other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag other}, []],
     "tag-other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag-other}, []],
     "tag, !other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag}, %w{other}],
     "tag, !other, one, !two: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag one}, %w{other two}],
     "tag: abuse@domain.com, other@domain.com" => [%w{abuse@domain.com other@domain.com}, %w{tag}, []]
 
   }.each do |line, results|
     it "should parse '#{line}' as #{results.inspect}" do
       @processor.parse(line).shift.should == results
     end
   end
 
   describe "when matching logs" do
     before do
       @processor << Puppet::Util::Log.new(:level => :notice, :message => "first", :tags => %w{one})
       @processor << Puppet::Util::Log.new(:level => :notice, :message => "second", :tags => %w{one two})
       @processor << Puppet::Util::Log.new(:level => :notice, :message => "third", :tags => %w{one two three})
     end
 
     def match(pos = [], neg = [])
       pos = Array(pos)
       neg = Array(neg)
       result = @processor.match([[%w{abuse@domain.com}, pos, neg]])
       actual_result = result.shift
       if actual_result
         actual_result[1]
       else
         nil
       end
     end
 
     it "should match all messages when provided the 'all' tag as a positive matcher" do
       results = match("all")
       %w{first second third}.each do |str|
         results.should be_include(str)
       end
     end
 
     it "should remove messages that match a negated tag" do
       match("all", "three").should_not be_include("third")
     end
 
     it "should find any messages tagged with a provided tag" do
       results = match("two")
       results.should be_include("second")
       results.should be_include("third")
       results.should_not be_include("first")
     end
 
     it "should allow negation of specific tags from a specific tag list" do
       results = match("two", "three")
       results.should be_include("second")
       results.should_not be_include("third")
     end
 
     it "should allow a tag to negate all matches" do
       results = match([], "one")
       results.should be_nil
     end
   end
 
   describe "the behavior of tagmail.process" do
     before do
       Puppet[:tagmap] = my_fixture "tagmail_email.conf"
     end
 
     let(:processor) do
       processor = Puppet::Transaction::Report.new("apply")
       processor.extend(Puppet::Reports.report(:tagmail))
       processor
     end
 
     context "when any messages match a positive tag" do
       before do
         processor << log_entry
       end
 
       let(:log_entry) do
         Puppet::Util::Log.new(
           :level => :notice, :message => "Secure change", :tags => %w{secure})
       end
 
       let(:message) do
         "#{log_entry.time} Puppet (notice): Secure change"
       end
 
       it "should send email if there are changes" do
         processor.expects(:send).with([[['user@domain.com'], message]])
         processor.expects(:raw_summary).returns({
           "resources" => { "changed" => 1, "out_of_sync" => 0 }
         })
 
         processor.process
       end
 
       it "should send email if there are resources out of sync" do
         processor.expects(:send).with([[['user@domain.com'], message]])
         processor.expects(:raw_summary).returns({
           "resources" => { "changed" => 0, "out_of_sync" => 1 }
         })
 
         processor.process
       end
 
       it "should not send email if no changes or resources out of sync" do
         processor.expects(:send).never
         processor.expects(:raw_summary).returns({
           "resources" => { "changed" => 0, "out_of_sync" => 0 }
         })
 
         processor.process
       end
 
       it "should log a message if no changes or resources out of sync" do
         processor.expects(:send).never
         processor.expects(:raw_summary).returns({
           "resources" => { "changed" => 0, "out_of_sync" => 0 }
         })
 
         Puppet.expects(:notice).with("Not sending tagmail report; no changes")
         processor.process
       end
 
       it "should send email if raw_summary is not defined" do
         processor.expects(:send).with([[['user@domain.com'], message]])
         processor.expects(:raw_summary).returns(nil)
         processor.process
       end
 
       it "should send email if there are no resource metrics" do
         processor.expects(:send).with([[['user@domain.com'], message]])
         processor.expects(:raw_summary).returns({'resources' => nil})
         processor.process
       end
     end
+
+    context "when no message match a positive tag" do
+      before do
+        processor << log_entry
+      end
+
+      let(:log_entry) do
+        Puppet::Util::Log.new(
+          :level   => :notice,
+          :message => 'Unnotices change',
+          :tags    => %w{not_present_in_tagmail.conf}
+        )
+      end
+
+      it "should send no email if there are changes" do
+        processor.expects(:send).never
+        processor.expects(:raw_summary).returns({
+          "resources" => { "changed" => 1, "out_of_sync" => 0 }
+        })
+        processor.process
+      end
+
+      it "should send no email if there are resources out of sync" do
+        processor.expects(:send).never
+        processor.expects(:raw_summary).returns({
+          "resources" => { "changed" => 0, "out_of_sync" => 1 }
+        })
+        processor.process
+      end
+
+      it "should send no email if no changes or resources out of sync" do
+        processor.expects(:send).never
+        processor.expects(:raw_summary).returns({
+          "resources" => { "changed" => 0, "out_of_sync" => 0 }
+        })
+        processor.process
+      end
+
+      it "should send no email if raw_summary is not defined" do
+        processor.expects(:send).never
+        processor.expects(:raw_summary).returns(nil)
+        processor.process
+      end
+
+      it "should send no email if there are no resource metrics" do
+        processor.expects(:send).never
+        processor.expects(:raw_summary).returns({'resources' => nil})
+        processor.process
+      end
+    end
   end
 end
 
diff --git a/spec/unit/type/cron_spec.rb b/spec/unit/type/cron_spec.rb
index 8216a5b11..7adafff48 100755
--- a/spec/unit/type/cron_spec.rb
+++ b/spec/unit/type/cron_spec.rb
@@ -1,477 +1,497 @@
 #!/usr/bin/env rspec
 
 require 'spec_helper'
 
 describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows? do
   before do
     @provider_class = described_class.provide(:simple) { mk_resource_methods }
     @provider_class.stubs(:suitable?).returns true
     described_class.stubs(:defaultprovider).returns @provider_class
   end
 
   it "should have :name be its namevar" do
     described_class.key_attributes.should == [:name]
   end
 
   describe "when validating attributes" do
     [:name, :provider].each do |param|
       it "should have a #{param} parameter" do
         described_class.attrtype(param).should == :param
       end
     end
 
     [:command, :special, :minute, :hour, :weekday, :month, :monthday, :environment, :user, :target].each do |property|
       it "should have a #{property} property" do
         described_class.attrtype(property).should == :property
       end
     end
 
     [:command, :minute, :hour, :weekday, :month, :monthday].each do |cronparam|
       it "should have #{cronparam} of type CronParam" do
         described_class.attrclass(cronparam).ancestors.should include CronParam
       end
     end
   end
 
 
-  describe "when validating attribute" do
+  describe "when validating values" do
+
     describe "ensure" do
       it "should support present as a value for ensure" do
         proc { described_class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
       end
 
       it "should support absent as a value for ensure" do
         proc { described_class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
       end
 
       it "should not support other values" do
         proc { described_class.new(:name => 'foo', :ensure => :foo) }.should raise_error(Puppet::Error, /Invalid value/)
       end
     end
 
     describe "minute" do
       it "should support absent" do
         proc { described_class.new(:name => 'foo', :minute => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { described_class.new(:name => 'foo', :minute => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         described_class.new(:name => 'foo', :minute => 'absent')[:minute].should == :absent
       end
 
       it "should translate * to :absent" do
         described_class.new(:name => 'foo', :minute => '*')[:minute].should == :absent
       end
 
       it "should support valid single values" do
         proc { described_class.new(:name => 'foo', :minute => '0') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :minute => '1') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :minute => '59') }.should_not raise_error
       end
 
       it "should not support non numeric characters" do
         proc { described_class.new(:name => 'foo', :minute => 'z59') }.should raise_error(Puppet::Error, /z59 is not a valid minute/)
         proc { described_class.new(:name => 'foo', :minute => '5z9') }.should raise_error(Puppet::Error, /5z9 is not a valid minute/)
         proc { described_class.new(:name => 'foo', :minute => '59z') }.should raise_error(Puppet::Error, /59z is not a valid minute/)
       end
 
       it "should not support single values out of range" do
 
         proc { described_class.new(:name => 'foo', :minute => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid minute/)
         proc { described_class.new(:name => 'foo', :minute => '60') }.should raise_error(Puppet::Error, /60 is not a valid minute/)
         proc { described_class.new(:name => 'foo', :minute => '61') }.should raise_error(Puppet::Error, /61 is not a valid minute/)
         proc { described_class.new(:name => 'foo', :minute => '120') }.should raise_error(Puppet::Error, /120 is not a valid minute/)
       end
 
       it "should support valid multiple values" do
         proc { described_class.new(:name => 'foo', :minute => ['0','1','59'] ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :minute => ['40','30','20'] ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :minute => ['10','30','20'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { described_class.new(:name => 'foo', :minute => ['0','1','60'] ) }.should raise_error(Puppet::Error, /60 is not a valid minute/)
         proc { described_class.new(:name => 'foo', :minute => ['0','120','59'] ) }.should raise_error(Puppet::Error, /120 is not a valid minute/)
         proc { described_class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.should raise_error(Puppet::Error, /-1 is not a valid minute/)
         # two invalid
         proc { described_class.new(:name => 'foo', :minute => ['0','61','62'] ) }.should raise_error(Puppet::Error, /(61|62) is not a valid minute/)
         # all invalid
         proc { described_class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.should raise_error(Puppet::Error, /(-1|61|62) is not a valid minute/)
       end
 
       it "should support valid step syntax" do
         proc { described_class.new(:name => 'foo', :minute => '*/2' ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :minute => '10-16/2' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { described_class.new(:name => 'foo', :minute => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid minute/)
         proc { described_class.new(:name => 'foo', :minute => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid minute/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { described_class.new(:name => 'foo', :minute => '*/120' ) }.should raise_error(Puppet::Error, /is not a valid minute/)
       end
     end
 
     describe "hour" do
       it "should support absent" do
         proc { described_class.new(:name => 'foo', :hour => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { described_class.new(:name => 'foo', :hour => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         described_class.new(:name => 'foo', :hour => 'absent')[:hour].should == :absent
       end
 
       it "should translate * to :absent" do
         described_class.new(:name => 'foo', :hour => '*')[:hour].should == :absent
       end
 
       it "should support valid single values" do
         proc { described_class.new(:name => 'foo', :hour => '0') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :hour => '11') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :hour => '12') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :hour => '13') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :hour => '23') }.should_not raise_error
       end
 
       it "should not support non numeric characters" do
         proc { described_class.new(:name => 'foo', :hour => 'z15') }.should raise_error(Puppet::Error, /z15 is not a valid hour/)
         proc { described_class.new(:name => 'foo', :hour => '1z5') }.should raise_error(Puppet::Error, /1z5 is not a valid hour/)
         proc { described_class.new(:name => 'foo', :hour => '15z') }.should raise_error(Puppet::Error, /15z is not a valid hour/)
       end
 
       it "should not support single values out of range" do
         proc { described_class.new(:name => 'foo', :hour => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
         proc { described_class.new(:name => 'foo', :hour => '24') }.should raise_error(Puppet::Error, /24 is not a valid hour/)
         proc { described_class.new(:name => 'foo', :hour => '120') }.should raise_error(Puppet::Error, /120 is not a valid hour/)
       end
 
       it "should support valid multiple values" do
         proc { described_class.new(:name => 'foo', :hour => ['0','1','23'] ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :hour => ['5','16','14'] ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :hour => ['16','13','9'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { described_class.new(:name => 'foo', :hour => ['0','1','24'] ) }.should raise_error(Puppet::Error, /24 is not a valid hour/)
         proc { described_class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
         proc { described_class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
         # two invalid
         proc { described_class.new(:name => 'foo', :hour => ['0','25','26'] ) }.should raise_error(Puppet::Error, /(25|26) is not a valid hour/)
         # all invalid
         proc { described_class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.should raise_error(Puppet::Error, /(-1|24|120) is not a valid hour/)
       end
 
       it "should support valid step syntax" do
         proc { described_class.new(:name => 'foo', :hour => '*/2' ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :hour => '10-18/4' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { described_class.new(:name => 'foo', :hour => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid hour/)
         proc { described_class.new(:name => 'foo', :hour => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid hour/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { described_class.new(:name => 'foo', :hour => '*/26' ) }.should raise_error(Puppet::Error, /is not a valid hour/)
       end
     end
 
     describe "weekday" do
       it "should support absent" do
         proc { described_class.new(:name => 'foo', :weekday => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { described_class.new(:name => 'foo', :weekday => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         described_class.new(:name => 'foo', :weekday => 'absent')[:weekday].should == :absent
       end
 
       it "should translate * to :absent" do
         described_class.new(:name => 'foo', :weekday => '*')[:weekday].should == :absent
       end
 
       it "should support valid numeric weekdays" do
         proc { described_class.new(:name => 'foo', :weekday => '0') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => '1') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => '6') }.should_not raise_error
         # According to http://www.manpagez.com/man/5/crontab 7 is also valid (Sunday)
         proc { described_class.new(:name => 'foo', :weekday => '7') }.should_not raise_error
       end
 
       it "should support valid weekdays as words (long version)" do
         proc { described_class.new(:name => 'foo', :weekday => 'Monday') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Tuesday') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Wednesday') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Thursday') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Friday') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Saturday') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Sunday') }.should_not raise_error
       end
 
       it "should support valid weekdays as words (3 character version)" do
         proc { described_class.new(:name => 'foo', :weekday => 'Mon') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Tue') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Wed') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Thu') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Fri') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Sat') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => 'Sun') }.should_not raise_error
       end
 
       it "should not support numeric values out of range" do
         proc { described_class.new(:name => 'foo', :weekday => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid weekday/)
         proc { described_class.new(:name => 'foo', :weekday => '8') }.should raise_error(Puppet::Error, /8 is not a valid weekday/)
       end
 
       it "should not support invalid weekday names" do
         proc { described_class.new(:name => 'foo', :weekday => 'Sar') }.should raise_error(Puppet::Error, /Sar is not a valid weekday/)
       end
 
       it "should support valid multiple values" do
         proc { described_class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { described_class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.should raise_error(Puppet::Error, /8 is not a valid weekday/)
         proc { described_class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.should raise_error(Puppet::Error, /Fii is not a valid weekday/)
         # two invalid
         proc { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.should raise_error(Puppet::Error, /(Mos|Fii) is not a valid weekday/)
         # all invalid
         proc { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.should raise_error(Puppet::Error, /(Mos|Fii|Saa) is not a valid weekday/)
         proc { described_class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.should raise_error(Puppet::Error, /(-1|8|11) is not a valid weekday/)
       end
 
       it "should support valid step syntax" do
         proc { described_class.new(:name => 'foo', :weekday => '*/2' ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :weekday => '0-4/2' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { described_class.new(:name => 'foo', :weekday => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid weekday/)
         proc { described_class.new(:name => 'foo', :weekday => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid weekday/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { described_class.new(:name => 'foo', :weekday => '*/9' ) }.should raise_error(Puppet::Error, /is not a valid weekday/)
       end
     end
 
     describe "month" do
       it "should support absent" do
         proc { described_class.new(:name => 'foo', :month => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { described_class.new(:name => 'foo', :month => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         described_class.new(:name => 'foo', :month => 'absent')[:month].should == :absent
       end
 
       it "should translate * to :absent" do
         described_class.new(:name => 'foo', :month => '*')[:month].should == :absent
       end
 
       it "should support valid numeric values" do
         proc { described_class.new(:name => 'foo', :month => '1') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => '12') }.should_not raise_error
       end
 
       it "should support valid months as words" do
         proc { described_class.new(:name => 'foo', :month => 'January') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'February') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'March') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'April') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'May') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'June') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'July') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'August') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'September') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'October') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'November') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'December') }.should_not raise_error
       end
 
       it "should support valid months as words (3 character short version)" do
         proc { described_class.new(:name => 'foo', :month => 'Jan') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Feb') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Mar') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Apr') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'May') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Jun') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Jul') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Aug') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Sep') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Oct') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Nov') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => 'Dec') }.should_not raise_error
       end
 
       it "should not support numeric values out of range" do
         proc { described_class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => '0') }.should raise_error(Puppet::Error, /0 is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => '13') }.should raise_error(Puppet::Error, /13 is not a valid month/)
       end
 
       it "should not support words that are not valid months" do
         proc { described_class.new(:name => 'foo', :month => 'Jal') }.should raise_error(Puppet::Error, /Jal is not a valid month/)
       end
 
       it "should not support single values out of range" do
 
         proc { described_class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => '60') }.should raise_error(Puppet::Error, /60 is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => '61') }.should raise_error(Puppet::Error, /61 is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => '120') }.should raise_error(Puppet::Error, /120 is not a valid month/)
       end
 
       it "should support valid multiple values" do
         proc { described_class.new(:name => 'foo', :month => ['1','9','12'] ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { described_class.new(:name => 'foo', :month => ['0','1','12'] ) }.should raise_error(Puppet::Error, /0 is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => ['1','13','10'] ) }.should raise_error(Puppet::Error, /13 is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.should raise_error(Puppet::Error, /Jxx is not a valid month/)
         # two invalid
         proc { described_class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.should raise_error(Puppet::Error, /(Fex|Jux) is not a valid month/)
         # all invalid
         proc { described_class.new(:name => 'foo', :month => ['-1','0','13'] ) }.should raise_error(Puppet::Error, /(-1|0|13) is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.should raise_error(Puppet::Error, /(Jax|Fex|Aux) is not a valid month/)
       end
 
       it "should support valid step syntax" do
         proc { described_class.new(:name => 'foo', :month => '*/2' ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :month => '1-12/3' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { described_class.new(:name => 'foo', :month => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid month/)
         proc { described_class.new(:name => 'foo', :month => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid month/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { described_class.new(:name => 'foo', :month => '*/13' ) }.should raise_error(Puppet::Error, /is not a valid month/)
       end
     end
 
     describe "monthday" do
       it "should support absent" do
         proc { described_class.new(:name => 'foo', :monthday => 'absent') }.should_not raise_error
       end
 
       it "should support *" do
         proc { described_class.new(:name => 'foo', :monthday => '*') }.should_not raise_error
       end
 
       it "should translate absent to :absent" do
         described_class.new(:name => 'foo', :monthday => 'absent')[:monthday].should == :absent
       end
 
       it "should translate * to :absent" do
         described_class.new(:name => 'foo', :monthday => '*')[:monthday].should == :absent
       end
 
       it "should support valid single values" do
         proc { described_class.new(:name => 'foo', :monthday => '1') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :monthday => '30') }.should_not raise_error
         proc { described_class.new(:name => 'foo', :monthday => '31') }.should_not raise_error
       end
 
       it "should not support non numeric characters" do
         proc { described_class.new(:name => 'foo', :monthday => 'z23') }.should raise_error(Puppet::Error, /z23 is not a valid monthday/)
         proc { described_class.new(:name => 'foo', :monthday => '2z3') }.should raise_error(Puppet::Error, /2z3 is not a valid monthday/)
         proc { described_class.new(:name => 'foo', :monthday => '23z') }.should raise_error(Puppet::Error, /23z is not a valid monthday/)
       end
 
       it "should not support single values out of range" do
         proc { described_class.new(:name => 'foo', :monthday => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid monthday/)
         proc { described_class.new(:name => 'foo', :monthday => '0') }.should raise_error(Puppet::Error, /0 is not a valid monthday/)
         proc { described_class.new(:name => 'foo', :monthday => '32') }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
       end
 
       it "should support valid multiple values" do
         proc { described_class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.should_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
         proc { described_class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
         proc { described_class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.should raise_error(Puppet::Error, /-1 is not a valid monthday/)
         proc { described_class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
         # two invalid
         proc { described_class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.should raise_error(Puppet::Error, /(-1|0) is not a valid monthday/)
         # all invalid
         proc { described_class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.should raise_error(Puppet::Error, /(-1|0|32) is not a valid monthday/)
       end
 
       it "should support valid step syntax" do
         proc { described_class.new(:name => 'foo', :monthday => '*/2' ) }.should_not raise_error
         proc { described_class.new(:name => 'foo', :monthday => '10-16/2' ) }.should_not raise_error
       end
 
       it "should not support invalid steps" do
         proc { described_class.new(:name => 'foo', :monthday => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid monthday/)
         proc { described_class.new(:name => 'foo', :monthday => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid monthday/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # proc { described_class.new(:name => 'foo', :monthday => '*/32' ) }.should raise_error(Puppet::Error, /is not a valid monthday/)
       end
     end
 
     describe "environment" do
       it "it should accept an :environment that looks like a path" do
         lambda do
           described_class.new(:name => 'foo',:environment => 'PATH=/bin:/usr/bin:/usr/sbin')
         end.should_not raise_error
       end
 
       it "should not accept environment variables that do not contain '='" do
         lambda do
           described_class.new(:name => 'foo',:environment => 'INVALID')
         end.should raise_error(Puppet::Error, /Invalid environment setting "INVALID"/)
       end
 
       it "should accept empty environment variables that do not contain '='" do
         lambda do
           described_class.new(:name => 'foo',:environment => 'MAILTO=')
         end.should_not raise_error(Puppet::Error)
       end
 
       it "should accept 'absent'" do
         lambda do
           described_class.new(:name => 'foo',:environment => 'absent')
         end.should_not raise_error(Puppet::Error)
       end
 
     end
   end
 
+  describe "when autorequiring resources" do
+
+    before :each do
+      @user_bob = Puppet::Type.type(:user).new(:name => 'bob', :ensure => :present)
+      @user_alice = Puppet::Type.type(:user).new(:name => 'alice', :ensure => :present)
+      @catalog = Puppet::Resource::Catalog.new
+      @catalog.add_resource @user_bob, @user_alice
+    end
+
+    it "should autorequire the user" do
+      @resource = described_class.new(:name => 'dummy', :command => '/usr/bin/uptime', :user => 'alice')
+      @catalog.add_resource @resource
+      req = @resource.autorequire
+      req.size.should == 1
+      req[0].target.must == @resource
+      req[0].source.must == @user_alice
+    end
+  end
+
   it "should require a command when adding an entry" do
     entry = described_class.new(:name => "test_entry", :ensure => :present)
     expect { entry.value(:command) }.should raise_error(Puppet::Error, /No command/)
   end
 
   it "should not require a command when removing an entry" do
     entry = described_class.new(:name => "test_entry", :ensure => :absent)
     entry.value(:command).should == nil
   end
 
   it "should default to user => root if Etc.getpwuid(Process.uid) returns nil (#12357)" do
     Etc.expects(:getpwuid).returns(nil)
     entry = described_class.new(:name => "test_entry", :ensure => :present)
     entry.value(:user).should eql "root"
   end
 end