puppet 0.22.4 → 0.23.0

data/test/ral/providers/service.rb

@@ -55,7 +55,7 @@ class TestLocalService < Test::Unit::TestCase
         }
 
         comp = newcomp("servicetst", service)
-        service[:ensure] = true
+        service[:ensure] = :running
 
         Puppet.info "Starting %s" % service.name
         assert_apply(service)
@@ -63,10 +63,15 @@ class TestLocalService < Test::Unit::TestCase
         # Some package systems background the work, so we need to give them
         # time to do their work.
         sleep(1.5)
+        props = nil
         assert_nothing_raised() {
-            service.retrieve
+            props = service.retrieve
         }
-        assert(service.insync?, "Service %s is not running" % service.name)
+        props.each do |prop, value|
+            if prop.name == :ensure
+                assert_equal(:running, value, "Service %s is not running" % service.name)
+            end
+        end
 
         # test refreshing it
         assert_nothing_raised() {
@@ -77,17 +82,22 @@ class TestLocalService < Test::Unit::TestCase
         assert_nothing_raised() {
             service[:ensure] = :stopped
         }
-        assert_nothing_raised() {
-            service.retrieve
-        }
-        assert(!service.insync?(), "Service %s is not running" % service.name)
+        props.each do |prop, value|
+            if prop.name == :ensure
+                assert_equal(:running, value, "Service %s is not running" % service.name)
+            end
+        end
         Puppet.info "stopping %s" % service.name
         assert_events([:service_stopped], comp)
         sleep(1.5)
         assert_nothing_raised() {
-            service.retrieve
+            props = service.retrieve
         }
-        assert(service.insync?, "Service %s has not stopped" % service.name)
+        props.each do |prop, value|
+            if prop.name == :ensure
+                assert_equal(:stopped, value, "Service %s is not running" % service.name)
+            end
+        end
     end
 
     def cycleenable(service)
@@ -104,26 +114,35 @@ class TestLocalService < Test::Unit::TestCase
         # Some package systems background the work, so we need to give them
         # time to do their work.
         sleep(1.5)
+        props = nil
         assert_nothing_raised() {
-            service.retrieve
+            props = service.retrieve
         }
-        assert(service.insync?, "Service %s is not enabled" % service.name)
+        props.each do |prop, value|
+            if prop.name == :enable
+                assert_equal(value, :true, "Service %s is not enabled" % service.name)
+            end
+        end
 
-        # now stop it
+        # now disable it
         assert_nothing_raised() {
             service[:enable] = false
         }
         assert_nothing_raised() {
-            service.retrieve
+            props = service.retrieve
         }
-        assert(!service.insync?(), "Service %s is not enabled" % service.name)
+        props.each do |prop, value|
+            assert_equal(value, :true, "Service %s is already disabled" % service.name)
+        end
         Puppet.info "disabling %s" % service.name
         assert_events([:service_disabled], comp)
         sleep(1.5)
         assert_nothing_raised() {
-            service.retrieve
+            props = service.retrieve
         }
-        assert(service.insync?, "Service %s has not been disabled" % service.name)
+        props.each do |prop, value|
+            assert_equal(value, :false, "Service %s is still enabled" % service.name)
+        end
     end
 
     def test_status
@@ -174,30 +193,37 @@ class TestLocalService < Test::Unit::TestCase
                 startenable = nil
                 startensure = nil
                 svc[:check] = [:ensure, :enable]
-                svc.retrieve
+                properties = nil
                 assert_nothing_raised("Could not get status") {
-                    startenable = svc.property(:enable).is
-                    startensure = svc.property(:ensure).is
+                    properties = svc.retrieve
                 }
+                initial = properties.dup
 
                 svc[:enable] = false
                 svc[:ensure] = :stopped
                 assert_apply(svc)
 
                 sleep 1
-                svc.retrieve
-                assert(svc.insync?, "Service did not sync both properties")
+                assert_nothing_raised("Could not get status") {
+                    properties = svc.retrieve
+                }
+                properties.each do |prop, value|
+                    assert(prop.insync?(value), "Service did not sync %s property" % prop.name)
+                end
 
                 svc[:enable] = true
                 svc[:ensure] = :running
                 assert_apply(svc)
 
                 sleep 1
-                svc.retrieve
-                assert(svc.insync?, "Service did not sync both properties")
+                assert_nothing_raised("Could not get status") {
+                    properties = svc.retrieve
+                }
+                assert(svc.insync?(properties), "Service did not sync both properties")
 
-                svc[:enable] = startenable
-                svc[:ensure] = startensure
+                initial.each do |prop, value|
+                    svc[prop.name] = value
+                end
                 assert_apply(svc)
                 Puppet.type(:component).clear
             end
@@ -206,4 +232,4 @@ class TestLocalService < Test::Unit::TestCase
 end
 end
 
-# $Id: service.rb 2236 2007-02-27 23:57:55Z luke $
+# $Id: service.rb 2555 2007-06-08 17:20:00Z luke $

data/test/ral/providers/sshkey/parsed.rb

@@ -38,9 +38,9 @@ class TestParsedSSHKey < Test::Unit::TestCase
             :ensure => :present
         }
 
-        fakemodel = fakemodel(:sshkey, args[:name])
+        fakeresource = fakeresource(:sshkey, args[:name])
 
-        key = @provider.new(fakemodel)
+        key = @provider.new(fakeresource)
         args.each do |p,v|
             key.send(p.to_s + "=", v)
         end
@@ -108,4 +108,4 @@ class TestParsedSSHKey < Test::Unit::TestCase
     end
 end
 
-# $Id: parsed.rb 2281 2007-03-14 17:49:19Z luke $
+# $Id: parsed.rb 2501 2007-05-09 23:08:42Z luke $

data/test/ral/providers/user.rb

@@ -128,11 +128,11 @@ class TestUserProvider < Test::Unit::TestCase
         end
     end
 
-    def fakemodel(*args)
-        model = super
+    def fakeresource(*args)
+        resource = super
 
         # Set boolean methods as necessary.
-        class << model
+        class << resource
             def allowdupe?
                 self[:allowdupe]
             end
@@ -140,14 +140,14 @@ class TestUserProvider < Test::Unit::TestCase
                 self[:managehome]
             end
         end
-        model
+        resource
     end
 
     def mkuser(name)
-        fakemodel = fakemodel(:user, name)
+        fakeresource = fakeresource(:user, name)
         user = nil
         assert_nothing_raised {
-            user = @provider.new(fakemodel)
+            user = @provider.new(fakeresource)
         }
         assert(user, "Could not create provider user")
 
@@ -164,29 +164,28 @@ class TestUserProvider < Test::Unit::TestCase
 
         # Now try it by object
         assert_nothing_raised {
-            names = @provider.list
+            names = @provider.instances
         }
         assert(names.length > 0, "Listed no users as objects")
 
         names.each do |obj|
-            assert_instance_of(Puppet::Type.type(:user), obj)
-            assert(obj[:provider], "Provider was not set")
+            assert_instance_of(@provider, obj)
         end
     end
 
     def test_infocollection
-        fakemodel = fakemodel(:user, @me)
+        fakeresource = fakeresource(:user, @me)
 
         user = nil
         assert_nothing_raised {
-            user = @provider.new(fakemodel)
+            user = @provider.new(fakeresource)
         }
         assert(user, "Could not create user provider")
 
         Puppet::Type.type(:user).validproperties.each do |property|
             next if property == :ensure
             # This is mostly in place for the 'password' stuff.
-            next unless user.class.supports_parameter?(property)
+            next unless user.class.supports_parameter?(property) and Puppet.features.root?
             val = nil
             assert_nothing_raised {
                 val = user.send(property)
@@ -392,7 +391,7 @@ class TestUserProvider < Test::Unit::TestCase
 
         # Now add some of them to our user
         assert_nothing_raised {
-            user.model[:groups] = extra.join(",")
+            user.resource[:groups] = extra.join(",")
         }
 
         # Some tests to verify that groups work correctly startig from nothing
@@ -428,7 +427,7 @@ class TestUserProvider < Test::Unit::TestCase
 
             eachproperty do |property|
                 if val = fakedata(user.name, property)
-                    user.model[property] = val
+                    user.resource[property] = val
                 end
             end
 
@@ -459,7 +458,7 @@ class TestUserProvider < Test::Unit::TestCase
 
             eachproperty do |property|
                 if val = fakedata(user.name, property)
-                    user.model[property] = val
+                    user.resource[property] = val
                 end
             end
 
@@ -494,7 +493,7 @@ class TestUserProvider < Test::Unit::TestCase
             user1.create
             user1.uid = 125
             user2 = mkuser("user2")
-            user2.model[:uid] = 125
+            user2.resource[:uid] = 125
 
             cleanup do
                 user1.ensure = :absent
@@ -504,7 +503,7 @@ class TestUserProvider < Test::Unit::TestCase
             # Not all OSes fail here, so we can't test that it doesn't work with
             # it off, only that it does work with it on.
             assert_nothing_raised {
-                user2.model[:allowdupe] = :true
+                user2.resource[:allowdupe] = :true
             }
             assert_nothing_raised { user2.create }
             assert_equal(:present, user2.ensure,
@@ -524,8 +523,8 @@ class TestUserProvider < Test::Unit::TestCase
 
         user = nil
         assert_nothing_raised {
-            fakemodel = fakemodel(:user, @me)
-            user = useradd.new(fakemodel)
+            fakeresource = fakeresource(:user, @me)
+            user = useradd.new(fakeresource)
         }
 
         assert_equal("-d", user.send(:flag, :home),
@@ -564,4 +563,4 @@ class TestUserProvider < Test::Unit::TestCase
     end
 end
 
-# $Id: user.rb 2444 2007-05-01 03:14:09Z luke $
+# $Id: user.rb 2555 2007-06-08 17:20:00Z luke $

data/test/ral/providers/user/useradd.rb

@@ -29,7 +29,6 @@ class UserAddProviderTest < PuppetTest::TestCase
 
         @vals.each do |name, val|
             next unless @user.class.validproperty?(name)
-            @user.is = [name, :absent]
         end
         @user
     end
@@ -46,7 +45,6 @@ class UserAddProviderTest < PuppetTest::TestCase
 
         @vals.each do |name, val|
             next unless user.class.validproperty?(name)
-            user.is = [name, :absent]
         end
 
         user.expects(:allowdupe?).returns(false)
@@ -204,8 +202,6 @@ class UserAddProviderTest < PuppetTest::TestCase
 
         # Now mark the user made, and make sure the right command is called
         setup_user
-        @user.is = [:ensure, :present]
-        @user.is = [:password, :present]
         @vals[:password] = "somethingelse"
 
 		@user.provider.expects(:execute).with do |params|
@@ -247,4 +243,4 @@ class UserRootAddProviderTest < PuppetTest::TestCase
 end
 
 
-# $Id: useradd.rb 2444 2007-05-01 03:14:09Z luke $
+# $Id: useradd.rb 2487 2007-05-09 01:51:20Z ballman $

data/test/ral/types/cron.rb

@@ -97,9 +97,9 @@ class TestCron < Test::Unit::TestCase
 
         assert_events([:cron_created], comp)
         cron.provider.class.prefetch
-        cron.retrieve
+        currentvalue = cron.retrieve
 
-        assert(cron.insync?, "Cron is not in sync")
+        assert(cron.insync?(currentvalue), "Cron is not in sync")
 
         assert_events([], comp)
 
@@ -114,9 +114,9 @@ class TestCron < Test::Unit::TestCase
         assert_events([:cron_removed], comp)
 
         cron.provider.class.prefetch
-        cron.retrieve
+        currentvalue = cron.retrieve
 
-        assert(cron.insync?, "Cron is not in sync")
+        assert(cron.insync?(currentvalue), "Cron is not in sync")
         assert_events([], comp)
     end
 
@@ -137,10 +137,12 @@ class TestCron < Test::Unit::TestCase
             }
             property = cron.send(:property, :command)
             cron.provider.command = command
+            cron.provider.ensure = :present
+            cron.provider.month = ["4"]
             cron.provider.class.prefetch
-            cron.retrieve
+            currentvalue = cron.retrieve
 
-            assert(property.insync?, "command parsing removes trailing whitespace")
+            assert(cron.insync?(currentvalue), "command parsing removes trailing whitespace")
             @crontype.clear
         end
     end
@@ -230,12 +232,14 @@ class TestCron < Test::Unit::TestCase
                 )
             }
 
-            minute = cron.send(:property, :minute)
+            #minute = cron.send(:property, :minute)
+            cron.provider.ensure = :present
+            cron.provider.command = '/bin/date > /dev/null'
             cron.provider.minute = %w{0 30}
             cron.provider.class.prefetch
-            cron.retrieve
+            currentvalue = cron.retrieve
 
-            assert(minute.insync?, "minute is out of sync with %s" % provider.name)
+            assert(cron.insync?(currentvalue), "minute is out of sync with %s" % provider.name)
             @crontype.clear
         end
     end
@@ -256,11 +260,13 @@ class TestCron < Test::Unit::TestCase
 
         cron[:minute] = :absent
         assert_events([:cron_changed], cron)
+
+        current_values = nil
         assert_nothing_raised {
             cron.provider.class.prefetch
-            cron.retrieve
+            current_values = cron.retrieve
         }
-        assert_equal(:absent, cron.is(:minute))
+        assert_equal(:absent, current_values[cron.property(:minute)])
     end
 
     def test_listing
@@ -281,9 +287,11 @@ class TestCron < Test::Unit::TestCase
         # Write it to our file
         assert_apply(cron)
 
+        @crontype.clear
+
         crons = []
         assert_nothing_raised {
-            @crontype.list.each do |cron|
+            @crontype.instances.each do |cron|
                 crons << cron
             end
         }
@@ -325,9 +333,9 @@ class TestCron < Test::Unit::TestCase
         assert_apply(cron)
 
         cron.provider.class.prefetch
-        cron.retrieve
+        currentvalue = cron.retrieve
 
-        assert_equal(["*/5"], cron.is(:minute))
+        assert_equal(["*/5"], currentvalue[cron.property(:minute)])
     end
 
     def test_ranges
@@ -336,10 +344,22 @@ class TestCron < Test::Unit::TestCase
 
         assert_apply(cron)
 
-        cron.provider.class.prefetch
-        cron.retrieve
+        current_values = nil
+        assert_nothing_raised {
+            cron.provider.class.prefetch
+            current_values = cron.retrieve
+        }
 
-        assert_equal(["2-4"], cron.is(:minute))
+        assert_equal(["2-4"], current_values[cron.property(:minute)])
+    end
+
+
+    def provider_set(cron, param, value)
+      unless param =~ /=$/
+        param = "%s=" % param
+      end
+    
+      cron.provider.send(param, value)
     end
 
     def test_value
@@ -353,22 +373,19 @@ class TestCron < Test::Unit::TestCase
             assert(property, "Did not get %s property" % param)
 
             assert_nothing_raised {
-                property.is = :absent
+#                property.is = :absent
+                 provider_set(cron, param, :absent)
             }
 
-            val = [:absent]
+            val = "*"
             assert_equal(val, cron.value(param))
 
-            # Make sure we correctly get the "is" value if that's all there is
-            cron.is = [param, "1"]
-            assert_equal(%w{1}, cron.value(param))
-
             # Make sure arrays work, too
-            cron.is = [param, ["1"]]
+            provider_set(cron, param, ["1"])
             assert_equal(%w{1}, cron.value(param))
 
             # Make sure values get comma-joined
-            cron.is = [param, %w{2 3}]
+            provider_set(cron, param, %w{2 3})
             assert_equal(%w{2 3}, cron.value(param))
 
             # Make sure "should" values work, too
@@ -381,7 +398,7 @@ class TestCron < Test::Unit::TestCase
             cron[param] = ["4", "5"]
             assert_equal(%w{4 5}, cron.value(param))
 
-            cron.is = [param, :absent]
+            provider_set(cron, param, :absent)
             assert_equal(%w{4 5}, cron.value(param))
         end
 
@@ -393,20 +410,16 @@ class TestCron < Test::Unit::TestCase
         property = cron.property(:command)
 
         assert_nothing_raised {
-            property.is = :absent
+            provider_set(cron, :command, :absent)
         }
 
         param = :command
-        # Make sure we correctly get the "is" value if that's all there is
-        cron.is = [param, "/bin/echo"]
-        assert_equal("/bin/echo", cron.value(param))
-
         # Make sure arrays work, too
-        cron.is = [param, ["/bin/echo"]]
+        provider_set(cron, param, ["/bin/echo"])
         assert_equal("/bin/echo", cron.value(param))
 
         # Make sure values are not comma-joined
-        cron.is = [param, %w{/bin/echo /bin/test}]
+        provider_set(cron, param, %w{/bin/echo /bin/test})
         assert_equal("/bin/echo", cron.value(param))
 
         # Make sure "should" values work, too
@@ -419,7 +432,7 @@ class TestCron < Test::Unit::TestCase
         cron[param] = %w{/bin/echo /bin/test}
         assert_equal("/bin/echo", cron.value(param))
 
-        cron.is = [param, :absent]
+        provider_set(cron, param, :absent)
         assert_equal("/bin/echo", cron.value(param))
     end
 
@@ -455,7 +468,7 @@ class TestCron < Test::Unit::TestCase
     end
 
     # Make sure the user stuff defaults correctly.
-    def test_default_user
+    def  test_default_user
         crontab = @crontype.provider(:crontab)
         if crontab.suitable?
             inst = @crontype.create(
@@ -477,4 +490,4 @@ class TestCron < Test::Unit::TestCase
 end
 
 
-# $Id: cron.rb 2414 2007-04-25 20:59:00Z luke $
+# $Id: cron.rb 2551 2007-06-04 20:37:14Z luke $