diff --git a/lib/puppet/metatype/evaluation.rb b/lib/puppet/metatype/evaluation.rb
index 4b8d293c4..b358fefad 100644
--- a/lib/puppet/metatype/evaluation.rb
+++ b/lib/puppet/metatype/evaluation.rb
@@ -1,156 +1,165 @@
 class Puppet::Type
     # This method is responsible for collecting property changes we always
     # descend into the children before we evaluate our current properties.
     # This returns any changes resulting from testing, thus 'collect' rather
     # than 'each'.
     def evaluate
         #Puppet.err "Evaluating %s" % self.path.join(":")
         unless defined? @evalcount
             self.err "No evalcount defined on '%s' of type '%s'" %
                 [self.title,self.class]
             @evalcount = 0
         end
         @evalcount += 1
 
         if p = self.provider and p.respond_to?(:prefetch)
             p.prefetch
         end
 
         # this only operates on properties, not properties + children
         # it's important that we call retrieve() on the type instance,
         # not directly on the property, because it allows the type to override
         # the method, like pfile does
         currentvalues = self.retrieve
 
         changes = propertychanges(currentvalues).flatten
 
         # now record how many changes we've resulted in
         if changes.length > 0
             self.debug "%s change(s)" %
                 [changes.length]
         end
-        self.cache(:checked, Time.now)
+
+        # If we're in noop mode, we don't want to store the checked time,
+        # because it will result in the resource not getting scheduled if
+        # someone were to run the configuration in non-noop mode.
+        # We're going to go ahead and record that we checked if there were
+        # no changes, since it's unlikely it will affect the scheduling.
+        noop = noop?
+        if ! noop or (noop && changes.length == 0)
+            self.cache(:checked, Time.now)
+        end
         return changes.flatten
     end
 
     # Flush the provider, if it supports it.  This is called by the
     # transaction.
     def flush
         if self.provider and self.provider.respond_to?(:flush)
             self.provider.flush
         end
     end
 
     # if all contained objects are in sync, then we're in sync
     # FIXME I don't think this is used on the type instances any more,
     # it's really only used for testing
     def insync?(is)
         insync = true
         
         if property = @parameters[:ensure]
             unless is.include? property
                raise Puppet::DevError,
                         "The is value is not in the is array for '%s'" %
                         [property.name]
             end
             ensureis = is[property]           
             if property.insync?(ensureis) and property.should == :absent
                 return true
             end
         end
 
         properties.each { |property|
             unless is.include? property
                raise Puppet::DevError,
                         "The is value is not in the is array for '%s'" %
                         [property.name]
             end
 
             propis = is[property]
             unless property.insync?(propis)
                 property.debug("Not in sync: %s vs %s" %
                     [propis.inspect, property.should.inspect])
                 insync = false
             #else
             #    property.debug("In sync")
             end
         }
 
         #self.debug("%s sync status is %s" % [self,insync])
         return insync
     end
         
     # retrieve the current value of all contained properties
     def retrieve
          return currentpropvalues
     end
     
     # get a hash of the current properties.  
     def currentpropvalues(override_value = nil)
         # it's important to use the method here, as it follows the order
         # in which they're defined in the object
         return properties().inject({}) { | prophash, property|
                    prophash[property] = override_value.nil? ? 
                                           property.retrieve : 
                                              override_value
                    prophash
                }
     end
 
     # Are we running in noop mode?
     def noop?
         @noop || Puppet[:noop]
     end
 
     def noop
         noop?
     end
      
     # Retrieve the changes associated with all of the properties.
     def propertychanges(currentvalues)
         # If we are changing the existence of the object, then none of
         # the other properties matter.
         changes = []
         ensureparam = @parameters[:ensure]
         if @parameters.include?(:ensure) && !currentvalues.include?(ensureparam)
             raise Puppet::DevError, "Parameter ensure defined but missing from current values"
         end
         if @parameters.include?(:ensure) and ! ensureparam.insync?(currentvalues[ensureparam])
 #            self.info "ensuring %s from %s" %
 #                [@parameters[:ensure].should, @parameters[:ensure].is]
             changes << Puppet::PropertyChange.new(ensureparam, currentvalues[ensureparam])
         # Else, if the 'ensure' property is correctly absent, then do
         # nothing
         elsif @parameters.include?(:ensure) and currentvalues[ensureparam] == :absent
             #            self.info "Object is correctly absent"
             return []
         else
 #            if @parameters.include?(:ensure)
 #                self.info "ensure: Is: %s, Should: %s" %
 #                    [@parameters[:ensure].is, @parameters[:ensure].should]
 #            else
 #                self.info "no ensure property"
 #            end
             changes = properties().find_all { |property|
                 unless currentvalues.include?(property)
                     raise Puppet::DevError, "Property %s does not have a current value", 
                                [property.name]
                 end
                 ! property.insync?(currentvalues[property])
             }.collect { |property|
                 Puppet::PropertyChange.new(property, currentvalues[property])
             }
         end
 
         if Puppet[:debug] and changes.length > 0
             self.debug("Changing " + changes.collect { |ch|
                     ch.property.name
                 }.join(",")
             )
         end
 
         changes
     end
 end
 
 # $Id$
diff --git a/test/ral/manager/type.rb b/test/ral/manager/type.rb
index cbe969fb3..292d66b28 100755
--- a/test/ral/manager/type.rb
+++ b/test/ral/manager/type.rb
@@ -1,820 +1,837 @@
 #!/usr/bin/env ruby
 
 $:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
 require 'mocha'
 
 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 properties
             #unless ! type.parameters.empty? or ! type.validproperties.empty?
             #    next
             #end
 
             assert_nothing_raised {
                 assert(
                     type.namevar,
                     "Failed to retrieve namevar for %s" % name
                 )
 
                 assert_not_nil(
                     type.properties,
                     "Properties for %s are nil" % name
                 )
 
                 assert_not_nil(
                     type.validproperties,
                     "Valid properties 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 property, but that
     # fundamentally doesn't make much sense, and we now don't have any such
     # types.
     def disabled_test_nameasproperty
         # currently groups are the only objects with the namevar as a property
         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_mergepropertyvalues
         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.property(:ensure), "User got an ensure property")
 
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestAB",
                 :comment => "Testingness"
             )
         }
         # but make sure it gets added once we manage them
         assert(user.property(:ensure), "User did not add ensure property")
 
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestBC",
                 :comment => "A fake user"
             )
         }
 
         # and make sure managed objects start with them
         assert(user.property(:ensure), "User did not get an ensure property")
     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(:component).create(:name => "middle")
 
         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_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_newproperty_options
         # Create a type with a fake provider
         providerclass = Class.new do
             def self.supports_parameter?(prop)
                 return true
             end
             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 property with no options.
         property = nil
         assert_nothing_raised do
             property = type.newproperty(:noopts) do
             end
         end
 
         # Now create an instance
         obj = type.create(:name => :myobj)
 
         inst = property.new(:resource => obj)
 
         # And make sure it's correctly setting @is
         ret = nil
         assert_nothing_raised {
             ret = inst.retrieve
         }
 
         assert_equal(:noopts, inst.retrieve)
 
         # Now create a property with a different way of doing it
         property = nil
         assert_nothing_raised do
             property = type.newproperty(:setretrieve, :retrieve => :yayness)
         end
 
         inst = property.new(:resource => obj)
 
         # And make sure it's correctly setting @is
         ret = nil
         assert_nothing_raised {
             ret = inst.retrieve
         }
 
         assert_equal(:yayness, ret)
     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()
         Puppet::Type.type(:exec) # uggh, the methods need to load the types
         file = Puppet::Type.newfile(:path => path)
         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
     
     def test_path
         # Check that our paths are built correctly.  Just pick a random, "normal" type.
         type = Puppet::Type.type(:exec)
         mk = Proc.new do |i, hash|
             hash[:title] = "exec%s" % i
             hash[:command] = "/bin/echo"
             type.create(hash)
         end
         
         exec = mk.call(1, {})
         
         assert_equal("/Exec[exec1]", exec.path)
         
         comp = Puppet::Type.newcomponent :title => "My[component]", :type => "Yay"
         
         exec = mk.call(2, :parent => comp)
         
         assert_equal("/My[component]/Exec[exec2]", exec.path)
         
         comp = Puppet::Type.newcomponent :name => "Other[thing]"
         exec = mk.call(3, :parent => comp)
         assert_equal("/Other[thing]/Exec[exec3]", exec.path)
         
         comp = Puppet::Type.newcomponent :type => "server", :name => "server"
         exec = mk.call(4, :parent => comp)
         assert_equal("/server/Exec[exec4]", exec.path)
         
         comp = Puppet::Type.newcomponent :type => "whatever", :name => "main[top]"
         exec = mk.call(5, :parent => comp)
         assert_equal("//Exec[exec5]", exec.path)
         
         comp = Puppet::Type.newcomponent :type => "yay", :name => "Good[bad]", :parent => comp
         exec = mk.call(6, :parent => comp)
         assert_equal("//Good[bad]/Exec[exec6]", exec.path)
     end
 
     def test_evaluate
         faketype = Puppet::Type.newtype(:faketype) do
             newparam(:name) {}
         end
         cleanup { Puppet::Type.rmtype(:faketype) }
         faketype.provide(:fake) do
             def prefetch
             end
         end
 
         obj = faketype.create :name => "yayness", :provider => :fake
         assert(obj, "did not create object")
 
         obj.provider.expects(:prefetch)
         obj.expects(:retrieve)
         obj.expects(:propertychanges).returns([])
         obj.expects(:cache)
 
         obj.evaluate
     end
 
     # Partially test #704, but also cover the rest of the schedule management bases.
     def test_schedule
         Puppet::Type.type(:schedule).create(:name => "maint")
 
         {"maint" => true, nil => false, :fail => :fail}.each do |name, should|
             args = {:name => tempfile, :ensure => :file}
             if name
                 args[:schedule] = name
             end
             resource = Puppet::Type.type(:file).create(args)
 
             if should == :fail
                 assert_raise(Puppet::Error, "Did not fail on missing schedule") do
                     resource.schedule
                 end
             else
                 sched = nil
                 assert_nothing_raised("Failed when schedule was %s" % sched) do
                     sched = resource.schedule
                 end
 
                 if should
                     assert_equal(name, sched.name, "did not get correct schedule back")
                 end
             end
         end
     end
-end
 
-# $Id$
+    # #801 -- resources only checked in noop should be rescheduled immediately.
+    def test_reschedule_when_noop
+        Puppet::Type.type(:schedule).mkdefaultschedules
+        file = Puppet::Type.type(:file).create(:path => "/tmp/whatever", :mode => "755", :noop => true, :schedule => :daily, :ensure => :file)
+
+        assert(file.noop?, "File not considered in noop")
+        assert(file.scheduled?, "File is not considered scheduled")
+
+        file.evaluate
+
+        assert_nil(file.cached(:checked), "Stored a checked time when running in noop mode when there were changes")
+        file.cache(:checked, nil)
+
+        file.stubs(:propertychanges).returns([])
+
+        file.evaluate
+        assert_instance_of(Time, file.cached(:checked), "Did not store a checked time when running in noop mode when there were no changes")
+    end
+end