puppet 0.22.4 → 0.23.0

data/test/ral/types/file.rb

@@ -31,6 +31,7 @@ class TestFile < Test::Unit::TestCase
         super
         @file = Puppet::Type.type(:file)
         $method = @method_name
+        Puppet[:filetimeout] = -1
     end
 
     def teardown
@@ -237,15 +238,15 @@ class TestFile < Test::Unit::TestCase
                 }
                 assert(changes.length > 0)
                 assert_apply(file)
-                file.retrieve
-                assert(file.insync?())
+                currentvalue = file.retrieve
+                assert(file.insync?(currentvalue))
                 assert_nothing_raised() {
                     file[:owner] = uid
                 }
                 assert_apply(file)
-                file.retrieve
+                currentvalue = file.retrieve
                 # make sure changing to number doesn't cause a sync
-                assert(file.insync?())
+                assert(file.insync?(currentvalue))
             }
 
             # We no longer raise an error here, because we check at run time
@@ -269,8 +270,8 @@ class TestFile < Test::Unit::TestCase
                 assert(file.property(:group))
                 assert(file.property(:group).should)
                 assert_apply(file)
-                file.retrieve
-                assert(file.insync?())
+                currentvalue = file.retrieve
+                assert(file.insync?(currentvalue))
                 assert_nothing_raised() {
                     file.delete(:group)
                 }
@@ -311,7 +312,7 @@ class TestFile < Test::Unit::TestCase
             assert_events([:file_created], file)
             assert_events([], file)
             assert(FileTest.file?(path), "File does not exist")
-            assert(file.insync?())
+            assert(file.insync?(file.retrieve))
             @@tmpfiles.push path
         }
     end
@@ -331,7 +332,7 @@ class TestFile < Test::Unit::TestCase
                 [path])
             assert_events([:directory_created], file)
             assert_events([], file)
-            assert(file.insync?())
+            assert(file.insync?(file.retrieve))
             assert(FileTest.directory?(path))
             @@tmpfiles.push path
         }
@@ -348,7 +349,7 @@ class TestFile < Test::Unit::TestCase
             assert_events([:file_changed], file)
             assert_events([], file)
 
-            assert(file.insync?())
+            assert(file.insync?(file.retrieve))
 
             assert_nothing_raised() {
                 file.delete(:mode)
@@ -387,11 +388,11 @@ class TestFile < Test::Unit::TestCase
                 }
                 trans = nil
 
-                file.retrieve
+                currentvalues = file.retrieve
 
                 if file.title !~ /nonexists/
                     sum = file.property(:checksum)
-                    assert(sum.insync?, "file is not in sync")
+                    assert(sum.insync?(currentvalues[sum]), "file is not in sync")
                 end
 
                 events = assert_apply(file)
@@ -424,10 +425,11 @@ class TestFile < Test::Unit::TestCase
 
                 # Run it a few times to make sure we aren't getting
                 # spurious changes.
+                sum = nil
                 assert_nothing_raised do
-                    file.property(:checksum).retrieve
+                    sum = file.property(:checksum).retrieve
                 end
-                assert(file.property(:checksum).insync?,
+                assert(file.property(:checksum).insync?(sum),
                     "checksum is not in sync")
 
                 sleep 1.1 if type =~ /time/
@@ -713,7 +715,7 @@ class TestFile < Test::Unit::TestCase
             file.evaluate
         }
 
-        assert_equal("directory", file.property(:type).is)
+        assert_equal("directory", file.property(:type).retrieve)
 
         # And then check files
         assert_nothing_raised {
@@ -727,15 +729,16 @@ class TestFile < Test::Unit::TestCase
         file[:check] = "type"
         assert_apply(file)
 
-        assert_equal("file", file.property(:type).is)
+        assert_equal("file", file.property(:type).retrieve)
 
         file[:type] = "directory"
 
-        assert_nothing_raised { file.retrieve }
+        currentvalues = {}
+        assert_nothing_raised { currentvalues = 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?)
+        assert(file.insync?(currentvalues))
     end
 
     def test_remove
@@ -840,13 +843,13 @@ class TestFile < Test::Unit::TestCase
             )
         }
 
-        assert(!obj.insync?, "Object is incorrectly in sync")
+        assert(!obj.insync?(obj.retrieve), "Object is incorrectly in sync")
 
         assert_events([:file_created], obj)
 
-        obj.retrieve
+        currentvalues = obj.retrieve
 
-        assert(obj.insync?, "Object is not in sync")
+        assert(obj.insync?(currentvalues), "Object is not in sync")
 
         text = File.read(file)
 
@@ -856,7 +859,7 @@ class TestFile < Test::Unit::TestCase
 
         obj[:content] = newstr
 
-        assert(!obj.insync?, "Object is incorrectly in sync")
+        assert(!obj.insync?(obj.retrieve), "Object is incorrectly in sync")
 
         assert_events([:file_changed], obj)
 
@@ -864,8 +867,8 @@ class TestFile < Test::Unit::TestCase
 
         assert_equal(newstr, text, "Content did not copy correctly")
 
-        obj.retrieve
-        assert(obj.insync?, "Object is not in sync")
+        currentvalues = obj.retrieve
+        assert(obj.insync?(currentvalues), "Object is not in sync")
     end
 
     # Unfortunately, I know this fails
@@ -943,7 +946,7 @@ class TestFile < Test::Unit::TestCase
             )
         }
 
-        file.retrieve
+        currentvalues = file.retrieve
 
         assert_events([:file_created], file)
         file.retrieve
@@ -1218,21 +1221,21 @@ class TestFile < Test::Unit::TestCase
 
         file = Puppet::Type.newfile(:path => path, :ensure => :present)
 
-        file.retrieve
-        assert(! file.insync?, "File incorrectly in sync")
+        currentvalues = file.retrieve
+        assert(! file.insync?(currentvalues), "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")
+        currentvalues = file.retrieve
+        assert(file.insync?(currentvalues), "File not in sync")
 
         # Now make a directory
         File.unlink(path)
         Dir.mkdir(path)
 
-        file.retrieve
-        assert(file.insync?, "Directory not considered 'present'")
+        currentvalues = file.retrieve
+        assert(file.insync?(currentvalues), "Directory not considered 'present'")
 
         Dir.rmdir(path)
 
@@ -1242,8 +1245,8 @@ class TestFile < Test::Unit::TestCase
         otherfile = tempfile()
         File.symlink(otherfile, path)
 
-        file.retrieve
-        assert(file.insync?, "Symlink not considered 'present'")
+        currentvalues = file.retrieve
+        assert(file.insync?(currentvalues), "Symlink not considered 'present'")
         File.unlink(path)
 
         # Now set some content, and make sure it works
@@ -1459,8 +1462,8 @@ class TestFile < Test::Unit::TestCase
 
                     property = obj.property(:ensure)
 
-                    property.retrieve
-                    unless property.insync?
+                    currentvalue = property.retrieve
+                    unless property.insync?(currentvalue)
                         assert_nothing_raised do
                             property.sync
                         end
@@ -1796,4 +1799,4 @@ class TestFile < Test::Unit::TestCase
     end
 end
 
-# $Id: file.rb 2436 2007-04-30 17:29:02Z luke $
+# $Id: file.rb 2629 2007-06-19 22:18:55Z luke $

data/test/ral/types/file/target.rb

@@ -222,19 +222,19 @@ class TestFileTarget < Test::Unit::TestCase
 
         prop = obj.send(:property, :target)
         prop.send(:instance_variable_set, "@should", [:nochange])
-        assert(prop.insync?,
+        assert(prop.insync?(prop.retrieve),
             "Property not in sync with should == :nochange")
 
         prop = obj.send(:property, :target)
         prop.send(:instance_variable_set, "@should", [:notlink])
-        assert(prop.insync?,
+        assert(prop.insync?(prop.retrieve),
             "Property not in sync with should == :nochange")
 
         # Lastly, make sure that we don't try to do anything when we're
         # recursing, since 'ensure' does the work.
         obj[:recurse] = true
         prop.should = dest
-        assert(prop.insync?,
+        assert(prop.insync?(prop.retrieve),
             "Still out of sync during recursion")
     end
 
@@ -360,4 +360,4 @@ class TestFileTarget < Test::Unit::TestCase
     end
 end
 
-# $Id: target.rb 2270 2007-03-08 07:37:43Z luke $
+# $Id: target.rb 2487 2007-05-09 01:51:20Z ballman $

data/test/ral/types/filesources.rb

@@ -16,6 +16,7 @@ class TestFileSources < Test::Unit::TestCase
             @port = 12345
         end
         @file = Puppet::Type.type(:file)
+        Puppet[:filetimeout] = -1
     end
     
     def use_storage
@@ -143,26 +144,27 @@ class TestFileSources < Test::Unit::TestCase
         assert_equal([source], property.should, "munging changed the source")
         
         # First try it with a missing source
+        currentvalue = nil
         assert_nothing_raised do
-            property.retrieve
+            currentvalue = property.retrieve
         end
         
         # And make sure the property considers itself in sync, since there's nothing
         # to do
-        assert(property.insync?, "source thinks there's work to do with no file or dest")
+        assert(property.insync?(currentvalue), "source thinks there's work to do with no file or dest")
         
         # Now make the dest a directory, and make sure the object sets :ensure
         # up to create a directory
         Dir.mkdir(source)
         assert_nothing_raised do
-            property.retrieve
+            currentvalue = property.retrieve
         end
         assert_equal(:directory, file.should(:ensure),
             "Did not set to create directory")
         
         # And make sure the source property won't try to do anything with a
         # remote dir
-        assert(property.insync?, "Source was out of sync even tho remote is dir")
+        assert(property.insync?(currentvalue), "Source was out of sync even tho remote is dir")
         
         # Now remove the source, and make sure :ensure was not modified
         Dir.rmdir(source)
@@ -205,29 +207,29 @@ class TestFileSources < Test::Unit::TestCase
         assert(property, "did not get source property")
         
         # Try it with no source at all
-        file.retrieve
-        assert(property.insync?, "source property not in sync with missing source")
+        currentvalues = file.retrieve
+        assert(property.insync?(currentvalues[property]), "source property not in sync with missing source")
 
         # with a directory
         Dir.mkdir(source)
-        file.retrieve
-        assert(property.insync?, "source property not in sync with directory as source")
+        currentvalues = file.retrieve
+        assert(property.insync?(currentvalues[property]), "source property not in sync with directory as source")
         Dir.rmdir(source)
         
         # with a file
         File.open(source, "w") { |f| f.puts "yay" }
-        file.retrieve
-        assert(!property.insync?, "source property was in sync when file was missing")
+        currentvalues = file.retrieve
+        assert(!property.insync?(currentvalues[property]), "source property was in sync when file was missing")
         
         # With a different file
         File.open(dest, "w") { |f| f.puts "foo" }
-        file.retrieve
-        assert(!property.insync?, "source property was in sync with different file")
+        currentvalues = file.retrieve
+        assert(!property.insync?(currentvalues[property]), "source property was in sync with different file")
         
         # with matching files
         File.open(dest, "w") { |f| f.puts "yay" }
-        file.retrieve
-        assert(property.insync?, "source property was not in sync with matching file")
+        currentvalues = file.retrieve
+        assert(property.insync?(currentvalues[property]), "source property was not in sync with matching file")
     end
     
     def test_source_sync
@@ -240,8 +242,8 @@ class TestFileSources < Test::Unit::TestCase
         
         File.open(source, "w") { |f| f.puts "yay" }
         
-        file.retrieve
-        assert(! property.insync?, "source thinks it's in sync")
+        currentvalues = file.retrieve
+        assert(! property.insync?(currentvalues[property]), "source thinks it's in sync")
         
         event = nil
         assert_nothing_raised do
@@ -253,8 +255,8 @@ class TestFileSources < Test::Unit::TestCase
         
         # Now write something different
         File.open(source, "w") { |f| f.puts "rah" }
-        file.retrieve
-        assert(! property.insync?, "source should be out of sync")
+        currentvalues = file.retrieve
+        assert(! property.insync?(currentvalues[property]), "source should be out of sync")
         assert_nothing_raised do
             event = property.sync
         end
@@ -692,12 +694,12 @@ class TestFileSources < Test::Unit::TestCase
             )
         }
 
-        file.retrieve
+        currentvalue = file.retrieve
 
-        assert(file.is(:checksum), "File does not have a checksum property")
+        assert(currentvalue[file.property(:checksum)], 
+               "File does not have a checksum property")
 
         assert_equal(0, file.evaluate.length, "File produced changes")
-
     end
 
     def test_sourcepaths
@@ -1043,4 +1045,4 @@ class TestFileSources < Test::Unit::TestCase
     end
 end
 
-# $Id: filesources.rb 2436 2007-04-30 17:29:02Z luke $
+# $Id: filesources.rb 2629 2007-06-19 22:18:55Z luke $

data/test/ral/types/group.rb

@@ -125,11 +125,13 @@ class TestGroup < Test::Unit::TestCase
             # Set a fake gid
             gobj.provider.gid = rand(100)
 
+            current_values = nil
             assert_nothing_raised {
-                gobj.retrieve
+                current_values = gobj.retrieve
             }
 
-            assert(gobj.is(:gid), "Failed to retrieve gid")
+            assert(current_values[gobj.property(:gid)], 
+                   "Failed to retrieve gid")
         }
     end
 

data/test/ral/types/host.rb

@@ -79,20 +79,21 @@ class TestHost < Test::Unit::TestCase
             )
         }
 
-        host.retrieve
+        current_values = nil
+        assert_nothing_raised { current_values = host.retrieve }
         assert_events([:host_created], host)
 
-        assert_nothing_raised { host.retrieve }
+        assert_nothing_raised { current_values = host.retrieve }
 
-        assert_equal(:present, host.is(:ensure))
+        assert_equal(:present, current_values[host.property(:ensure)])
 
         host[:ensure] = :absent
 
         assert_events([:host_removed], host)
 
-        assert_nothing_raised { host.retrieve }
+        assert_nothing_raised { current_values = host.retrieve }
 
-        assert_equal(:absent, host.is(:ensure))
+        assert_equal(:absent, current_values[host.property(:ensure)])
     end
 
     def test_moddinghost
@@ -111,18 +112,24 @@ class TestHost < Test::Unit::TestCase
 
         assert_events([:host_created], host)
 
-        host.retrieve
+        current_values = nil 
+        assert_nothing_raised {
+            current_values = host.retrieve
+        }
 
         # This was a hard bug to track down.
-        assert_instance_of(String, host.is(:ip))
+        assert_instance_of(String, current_values[host.property(:ip)])
 
         host[:alias] = %w{madstop kirby yayness}
 
         assert_events([:host_changed], host)
 
-        host.retrieve
+        assert_nothing_raised {
+            current_values = host.retrieve
+        }
 
-        assert_equal(%w{madstop kirby yayness}, host.is(:alias))
+        assert_equal(%w{madstop kirby yayness}, 
+                     current_values[host.property(:alias)])
         
         host[:ensure] = :absent
         assert_events([:host_removed], host)
@@ -152,4 +159,4 @@ class TestHost < Test::Unit::TestCase
     end
 end
 
-# $Id: host.rb 2170 2007-02-07 17:21:52Z luke $
+# $Id: host.rb 2487 2007-05-09 01:51:20Z ballman $

data/test/ral/types/mount.rb

@@ -18,10 +18,14 @@ class TestMounts < Test::Unit::TestCase
             :yayness
         end
 
+        def self.instances
+            []
+        end
+
         def create
             @ensure = :present
-            @model.class.validproperties.each do |property|
-                if value = @model.should(property)
+            @resource.class.validproperties.each do |property|
+                if value = @resource.should(property)
                     self.send(property.to_s + "=", value)
                 end
             end
@@ -178,38 +182,51 @@ class TestMounts < Test::Unit::TestCase
         assert_events([:mount_mounted, :triggered], obj)
         assert_events([], obj)
 
-        obj.retrieve
-        assert_equal(:mounted, obj.is(:ensure))
+        current_values = nil
+        assert_nothing_raised { current_values =  obj.retrieve }
+        assert_equal(:mounted, current_values[obj.property(:ensure)])
 
-        obj.retrieve
+        assert_nothing_raised { current_values =  obj.retrieve }
         assert(obj.provider.mounted?, "Object is not mounted")
     end
+
+    def test_defaults
+        obj = mkmount
+        args = mkmount_args
+        args.delete(:pass)
+        args.delete(:dump)
+        mount = nil
+
+        assert_nothing_raised {
+            mount = Puppet.type(:mount).create(args)
+        }
+
+        assert_equal(0, mount.should(:pass), "Did not set default for pass")
+        assert_equal(0, mount.should(:dump), "Did not set default for dump")
+    end
     
     # Darwin doesn't put its mount table into netinfo
     unless Facter.value(:operatingsystem) == "Darwin"
-    def test_list
-        list = nil
-        assert(@mount.respond_to?(:list),
-            "No list method defined for mount")
+    def test_instances
+        instances = nil
+        assert(@mount.respond_to?(:instances),
+            "No instances method defined for mount")
 
         assert_nothing_raised do
-            list = Puppet::Type.type(:mount).list
+            instances = Puppet::Type.type(:mount).instances
         end
         
-        assert(list.length > 0, "Did not return any mounts")
-
-        root = list.find { |o| o[:name] == "/" }
-        assert(root, "Could not find root root filesystem in list results")
-
-        assert(root.is(:device), "Device was not set")
-        assert(root.property(:device).value, "Device was not returned by value method")
+        assert(instances.length > 0, "Did not return any mounts")
 
+        root = instances.find { |o| o[:name] == "/" }
+        assert(root, "Could not find root root filesystem in instances results")
+  
+        current_values = nil
         assert_nothing_raised do
-            root.retrieve
+            current_values = root.retrieve
         end
 
-        assert(root.is(:device), "Device was not set")
-        assert(root.property(:device).value, "Device was not returned by value method")
+        assert(current_values[root.property(:device)], "Device was not set")
     end
     end
 
@@ -247,8 +264,8 @@ class TestMounts < Test::Unit::TestCase
         assert_events([], mount)
 
         # Now try listing and making sure the object is actually gone.
-        list = mount.provider.class.list
-        assert(! list.find { |r| r[:name] == mount[:name] },
+        instances = mount.provider.class.instances
+        assert(! instances.find { |r| r[:name] == mount[:name] },
             "Mount was not actually removed")
     end
     end
@@ -309,4 +326,4 @@ class TestMounts < Test::Unit::TestCase
 end
 end
 
-# $Id: mount.rb 2377 2007-03-31 06:35:23Z luke $
+# $Id: mount.rb 2563 2007-06-11 22:30:00Z luke $