puppet 0.24.9 → 0.25.0

data/test/ral/type/cron.rb

@@ -7,7 +7,7 @@ require 'puppettest'
 # Test cron job creation, modification, and destruction
 
 class TestCron < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
 
     def setup
         super
@@ -25,7 +25,6 @@ class TestCron < Test::Unit::TestCase
     def teardown
         super
         @crontype.defaultprovider = nil
-        Puppet::Util::FileType.filetype(:ram).clear
     end
 
     def eachprovider
@@ -38,7 +37,7 @@ class TestCron < Test::Unit::TestCase
     def cronback
         tab = nil
         assert_nothing_raised {
-            tab = Puppet.type(:cron).filetype.read(@me)
+            tab = Puppet::Type.type(:cron).filetype.read(@me)
         }
 
         if $? == 0
@@ -78,7 +77,7 @@ class TestCron < Test::Unit::TestCase
             args = {:command => command, :name => name}
         end
         assert_nothing_raised {
-            cron = @crontype.create(args)
+            cron = @crontype.new(args)
         }
 
         return cron
@@ -125,7 +124,7 @@ class TestCron < Test::Unit::TestCase
             name = "yaytest"
             command = "date > /dev/null "
             assert_nothing_raised {
-                cron = @crontype.create(
+                cron = @crontype.new(
                     :name => name,
                     :command => "date > /dev/null ",
                     :month => "May",
@@ -145,22 +144,20 @@ class TestCron < Test::Unit::TestCase
                 next unless prop.name.to_s == "command"
                 assert(prop.insync?(value), "Property %s is not considered in sync with value %s" % [prop.name, value.inspect])
             end
-
-            @crontype.clear
         end
     end
 
     def test_makeandretrievecron
         %w{storeandretrieve a-name another-name more_naming SomeName}.each do |name|
             cron = mkcron(name)
-            comp = mk_catalog(name, cron)
-            trans = assert_events([:cron_created], comp, name)
-            
+            catalog = mk_catalog(name, cron)
+            trans = assert_events([:cron_created], catalog, name)
+
             cron.provider.class.prefetch
             cron = nil
 
-            assert(cron = Puppet.type(:cron)[name], "Could not retrieve named cron")
-            assert_instance_of(Puppet.type(:cron), cron)
+            assert(cron = catalog.resource(:cron, name), "Could not retrieve named cron")
+            assert_instance_of(Puppet::Type.type(:cron), cron)
         end
     end
 
@@ -174,7 +171,7 @@ class TestCron < Test::Unit::TestCase
             :weekday => {
                 :valid => [ 0, 3, 6, "1", "tue", "wed",
                     "Wed", "MOnday", "SaTurday" ],
-                :invalid => [ -1, 7, "13", "tues", "teusday", "thurs" ]
+                :invalid => [ -1, 8, "13", "tues", "teusday", "thurs" ]
             },
             :hour => {
                 :valid => [ 0, 21, 23 ],
@@ -197,7 +194,7 @@ class TestCron < Test::Unit::TestCase
             [:valid, :invalid].each { |type|
                 hash[type].each { |value|
                     case type
-                    when :valid:
+                    when :valid
                         assert_nothing_raised {
                             cron[param] = value
                         }
@@ -206,7 +203,7 @@ class TestCron < Test::Unit::TestCase
                             assert_equal([value.to_s], cron.should(param),
                                 "Cron value was not set correctly")
                         end
-                    when :invalid:
+                    when :invalid
                         assert_raise(Puppet::Error, "%s is incorrectly a valid %s" %
                             [value, param]) {
                             cron[param] = value
@@ -227,7 +224,7 @@ class TestCron < Test::Unit::TestCase
         eachprovider do |provider|
             cron = nil
             assert_nothing_raised {
-                cron = @crontype.create(
+                cron = @crontype.new(
                     :command => "/bin/date > /dev/null",
                     :minute => [0, 30],
                     :name => "crontest",
@@ -247,14 +244,13 @@ class TestCron < Test::Unit::TestCase
                 next unless prop.name.to_s == "minute"
                 assert(prop.insync?(value), "Property %s is not considered in sync with value %s" % [prop.name, value.inspect])
             end
-            @crontype.clear
         end
     end
 
     def test_fieldremoval
         cron = nil
         assert_nothing_raised {
-            cron = @crontype.create(
+            cron = @crontype.new(
                 :command => "/bin/date > /dev/null",
                 :minute => [0, 30],
                 :name => "crontest",
@@ -286,7 +282,7 @@ class TestCron < Test::Unit::TestCase
         cleanup { provider.filetype = ft }
 
         setme
-        cron = @crontype.create(:name => "testing",
+        cron = @crontype.new(:name => "testing",
             :minute => [0, 30],
             :command => "/bin/testing",
             :user => @me
@@ -294,8 +290,6 @@ class TestCron < Test::Unit::TestCase
         # Write it to our file
         assert_apply(cron)
 
-        @crontype.clear
-
         crons = []
         assert_nothing_raised {
             @crontype.instances.each do |cron|
@@ -348,7 +342,7 @@ class TestCron < Test::Unit::TestCase
       unless param =~ /=$/
         param = "%s=" % param
       end
-    
+
       cron.provider.send(param, value)
     end
 
@@ -430,7 +424,7 @@ class TestCron < Test::Unit::TestCase
         crons = []
         users = ["root", nonrootuser.name]
         users.each do |user|
-            cron = Puppet::Type.type(:cron).create(
+            cron = Puppet::Type.type(:cron).new(
                 :name => "testcron-#{user}",
                 :user => user,
                 :command => "/bin/echo",
@@ -461,7 +455,7 @@ class TestCron < Test::Unit::TestCase
     def test_default_user
         crontab = @crontype.provider(:crontab)
         if crontab.suitable?
-            inst = @crontype.create(
+            inst = @crontype.new(
                 :name => "something", :command => "/some/thing",
                 :provider => :crontab)
             assert_equal(Etc.getpwuid(Process.uid).name, inst.should(:user),
@@ -471,7 +465,7 @@ class TestCron < Test::Unit::TestCase
 
             # Now make a new cron with a user, and make sure it gets copied
             # over
-            inst = @crontype.create(:name => "yay", :command => "/some/thing",
+            inst = @crontype.new(:name => "yay", :command => "/some/thing",
                 :user => "bin", :provider => :crontab)
             assert_equal("bin", inst.should(:target),
                 "target did not default to user with crontab")
@@ -481,11 +475,10 @@ class TestCron < Test::Unit::TestCase
     # #705 - make sure extra spaces don't screw things up
     def test_spaces_in_command
         string = "echo   multiple  spaces"
-        cron = @crontype.create(:name => "space testing", :command => string)
+        cron = @crontype.new(:name => "space testing", :command => string)
         assert_apply(cron)
 
-        cron.class.clear
-        cron = @crontype.create(:name => "space testing", :command => string)
+        cron = @crontype.new(:name => "space testing", :command => string)
 
         # Now make sure that it's correctly in sync
         cron.provider.class.prefetch("testing" => cron)

data/test/ral/type/exec.rb

@@ -5,12 +5,12 @@ require File.dirname(__FILE__) + '/../../lib/puppettest'
 require 'puppettest'
 
 class TestExec < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
     def test_execution
         command = nil
         output = nil
         assert_nothing_raised {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "/bin/echo"
             )
         }
@@ -22,12 +22,10 @@ class TestExec < Test::Unit::TestCase
 
     def test_numvsstring
         [0, "0"].each { |val|
-            Puppet.type(:exec).clear
-            Puppet.type(:component).clear
             command = nil
             output = nil
             assert_nothing_raised {
-                command = Puppet.type(:exec).create(
+                command = Puppet::Type.type(:exec).new(
                     :command => "/bin/echo",
                     :returns => val
                 )
@@ -40,25 +38,23 @@ class TestExec < Test::Unit::TestCase
         command = nil
         output = nil
         assert_raise(Puppet::Error) {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "echo"
             )
         }
         assert_nothing_raised {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "echo",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin"
             )
         }
-        Puppet.type(:exec).clear
         assert_nothing_raised {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "/bin/echo"
             )
         }
-        Puppet.type(:exec).clear
         assert_nothing_raised {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "/bin/echo",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin"
             )
@@ -67,21 +63,21 @@ class TestExec < Test::Unit::TestCase
 
     def test_nonzero_returns
         assert_nothing_raised {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "mkdir /this/directory/does/not/exist",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :returns => 1
             )
         }
         assert_nothing_raised {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "touch /etc",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :returns => 1
             )
         }
         assert_nothing_raised {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "thiscommanddoesnotexist",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :returns => 127
@@ -96,7 +92,7 @@ class TestExec < Test::Unit::TestCase
             Dir.getwd
         }
         assert_nothing_raised {
-            command = Puppet.type(:exec).create(
+            command = Puppet::Type.type(:exec).new(
                 :command => "pwd",
                 :cwd => dir,
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
@@ -113,7 +109,7 @@ class TestExec < Test::Unit::TestCase
         tmpfile = tempfile()
         @@tmpfiles.push tmpfile
         trans = nil
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :path => tmpfile,
             :content => "yay"
         )
@@ -123,7 +119,7 @@ class TestExec < Test::Unit::TestCase
         # Now make an exec
         maker = tempfile()
         assert_nothing_raised {
-            cmd = Puppet.type(:exec).create(
+            cmd = Puppet::Type.type(:exec).new(
                 :command => "touch %s" % maker,
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :subscribe => file,
@@ -149,7 +145,7 @@ class TestExec < Test::Unit::TestCase
     def test_refreshonly
         cmd = true
         assert_nothing_raised {
-            cmd = Puppet.type(:exec).create(
+            cmd = Puppet::Type.type(:exec).new(
                 :command => "pwd",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :refreshonly => true
@@ -172,7 +168,7 @@ class TestExec < Test::Unit::TestCase
         exec = nil
         assert(! FileTest.exists?(file), "File already exists")
         assert_nothing_raised {
-            exec = Puppet.type(:exec).create(
+            exec = Puppet::Type.type(:exec).new(
                 :command => "touch %s" % file,
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :creates => file
@@ -191,15 +187,15 @@ class TestExec < Test::Unit::TestCase
         sh = %x{which sh}
         File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :path => oexe,
             :source => exe,
             :mode => 0755
         )
 
-        exec = Puppet.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :command => oexe,
-            :require => [:file, oexe]
+            :require => Puppet::Resource::Reference.new(:file, oexe)
         )
 
         comp = mk_catalog("Testing", file, exec)
@@ -214,35 +210,37 @@ class TestExec < Test::Unit::TestCase
         sh = %x{which sh}
         File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :path => oexe,
             :source => exe,
             :mode => 755
         )
 
         basedir = File.dirname(oexe)
-        baseobj = Puppet.type(:file).create(
+        baseobj = Puppet::Type.type(:file).new(
             :path => basedir,
             :source => exe,
             :mode => 755
         )
 
-        ofile = Puppet.type(:file).create(
+        ofile = Puppet::Type.type(:file).new(
             :path => exe,
             :mode => 755
         )
 
-        exec = Puppet.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :command => oexe,
             :path => ENV["PATH"],
             :cwd => basedir
         )
 
-        cat = Puppet.type(:exec).create(
+        cat = Puppet::Type.type(:exec).new(
             :command => "cat %s %s" % [exe, oexe],
             :path => ENV["PATH"]
         )
-        
+
+        catalog = mk_catalog(file, baseobj, ofile, exec, cat)
+
         rels = nil
         assert_nothing_raised do
             rels = exec.autorequire
@@ -256,7 +254,6 @@ class TestExec < Test::Unit::TestCase
 
         # Verify we don't require ourselves
         assert(! rels.detect { |r| r.source == ofile }, "Exec incorrectly required mentioned file")
-        assert(!exec.requires?(ofile), "Exec incorrectly required file")
 
         # We not longer autorequire inline files
         assert_nothing_raised do
@@ -272,7 +269,7 @@ class TestExec < Test::Unit::TestCase
 
         exec = nil
         assert_nothing_raised {
-            exec = Puppet.type(:exec).create(
+            exec = Puppet::Type.type(:exec).new(
                 :command => "touch %s" % bfile,
                 :onlyif => "test -f %s" % afile,
                 :path => ENV['PATH']
@@ -293,7 +290,7 @@ class TestExec < Test::Unit::TestCase
 
         exec = nil
         assert_nothing_raised {
-            exec = Puppet.type(:exec).create(
+            exec = Puppet::Type.type(:exec).new(
                 :command => "touch %s" % bfile,
                 :unless => "test -f %s" % afile,
                 :path => ENV['PATH']
@@ -315,7 +312,7 @@ class TestExec < Test::Unit::TestCase
         # Verify that we can execute commands as a special user
         def mknverify(file, user, group = nil, id = true)
             File.umask(0022)
-                
+
             args = {
                 :command => "touch %s" % file,
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
@@ -341,7 +338,7 @@ class TestExec < Test::Unit::TestCase
             end
             exec = nil
             assert_nothing_raised {
-                exec = Puppet.type(:exec).create(args)
+                exec = Puppet::Type.type(:exec).new(args)
             }
 
             comp = mk_catalog("usertest", exec)
@@ -376,7 +373,7 @@ class TestExec < Test::Unit::TestCase
     def test_logoutput
         exec = nil
         assert_nothing_raised {
-            exec = Puppet.type(:exec).create(
+            exec = Puppet::Type.type(:exec).new(
                 :title => "logoutputesting",
                 :path => "/usr/bin:/bin",
                 :command => "echo logoutput is false",
@@ -407,7 +404,7 @@ class TestExec < Test::Unit::TestCase
         basedir = tempfile()
         path = File.join(basedir, "subfile")
         assert_nothing_raised {
-            exec = Puppet.type(:exec).create(
+            exec = Puppet::Type.type(:exec).new(
                 :title => "mkdir",
                 :path => "/usr/bin:/bin",
                 :creates => basedir,
@@ -417,11 +414,11 @@ class TestExec < Test::Unit::TestCase
         }
 
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :path => basedir,
                 :recurse => true,
                 :mode => "755",
-                :require => ["exec", "mkdir"]
+                :require => Puppet::Resource::Reference.new("exec", "mkdir")
             )
         }
 
@@ -437,14 +434,14 @@ class TestExec < Test::Unit::TestCase
     def test_falsevals
         exec = nil
         assert_nothing_raised do
-            exec = Puppet.type(:exec).create(
+            exec = Puppet::Type.type(:exec).new(
                 :command => "/bin/touch yayness"
             )
         end
 
-        Puppet.type(:exec).checks.each do |check|
-            klass = Puppet.type(:exec).paramclass(check)
-            next if klass.values.include? :false
+        Puppet::Type.type(:exec).checks.each do |check|
+            klass = Puppet::Type.type(:exec).paramclass(check)
+            next if klass.value_collection.values.include? :false
             assert_raise(Puppet::Error, "Check '%s' did not fail on false" % check) do
                 exec[check] = false
             end
@@ -457,7 +454,7 @@ class TestExec < Test::Unit::TestCase
         file = tempfile()
 
         assert_nothing_raised {
-            exec1 = Puppet.type(:exec).create(
+            exec1 = Puppet::Type.type(:exec).new(
                 :title => "one",
                 :path => ENV["PATH"],
                 :command => "mkdir #{dir}"
@@ -465,7 +462,7 @@ class TestExec < Test::Unit::TestCase
         }
 
         assert_nothing_raised("Could not create exec w/out existing cwd") {
-            exec2 = Puppet.type(:exec).create(
+            exec2 = Puppet::Type.type(:exec).new(
                 :title => "two",
                 :path => ENV["PATH"],
                 :command => "touch #{file}",
@@ -499,7 +496,7 @@ class TestExec < Test::Unit::TestCase
         test = "test -f #{file}"
 
         assert_nothing_raised {
-            exec = Puppet.type(:exec).create(
+            exec = Puppet::Type.type(:exec).new(
                 :path => ENV["PATH"],
                 :command => "touch #{file}"
             )
@@ -536,7 +533,7 @@ class TestExec < Test::Unit::TestCase
     def test_missing_checks_cause_failures
         # Solaris's sh exits with 1 here instead of 127
         return if Facter.value(:operatingsystem) == "Solaris"
-        exec = Puppet::Type.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
                                     :command => "echo true",
                                     :path => ENV["PATH"],
                                     :onlyif => "/bin/nosuchthingexists"
@@ -544,7 +541,7 @@ class TestExec < Test::Unit::TestCase
 
         assert_raise(ArgumentError, "Missing command did not raise error") {
             exec.run("/bin/nosuchthingexists")
-        } 
+        }
     end
 
     def test_envparam
@@ -586,7 +583,7 @@ and stuff"
         }
         assert_equal("A B\n", output)
     end
-    
+
     def test_environmentparam
         exec = Puppet::Type.newexec(
             :command => "echo $environmenttest",
@@ -628,15 +625,15 @@ and stuff"
     end
 
     def test_timeout
-        exec = Puppet::Type.type(:exec).create(:command => "sleep 1", :path => ENV["PATH"], :timeout => "0.2")
+        exec = Puppet::Type.type(:exec).new(:command => "sleep 1", :path => ENV["PATH"], :timeout => "0.2")
         time = Time.now
-        
+
         assert_raise(Timeout::Error) {
             exec.run("sleep 1")
         }
         Puppet.info "%s seconds, vs a timeout of %s" % [Time.now.to_f - time.to_f, exec[:timeout]]
-        
-        
+
+
         assert_apply(exec)
     end
 
@@ -646,7 +643,7 @@ and stuff"
         if Process.uid == 0
             user = "nosuchuser"
             assert_nothing_raised("Could not create exec with non-existent user") do
-                exec = Puppet::Type.type(:exec).create(
+                exec = Puppet::Type.type(:exec).new(
                     :command => "/bin/echo yay",
                     :user => user
                 )
@@ -656,7 +653,7 @@ and stuff"
         # Now try the group
         group = "nosuchgroup"
         assert_nothing_raised("Could not create exec with non-existent user") do
-            exec = Puppet::Type.type(:exec).create(
+            exec = Puppet::Type.type(:exec).new(
                 :command => "/bin/echo yay",
                 :group => group
             )
@@ -668,17 +665,17 @@ and stuff"
         path = %w{/usr/bin /usr/sbin /sbin}
         exec = nil
         assert_nothing_raised("Could not use an array for the path") do
-            exec = Puppet::Type.type(:exec).create(:command => "echo yay",
+            exec = Puppet::Type.type(:exec).new(:command => "echo yay",
                 :path => path)
         end
         assert_equal(path, exec[:path], "array-based path did not match")
         assert_nothing_raised("Could not use a string for the path") do
-            exec = Puppet::Type.type(:exec).create(:command => "echo yay",
+            exec = Puppet::Type.type(:exec).new(:command => "echo yay",
                 :path => path.join(":"))
         end
         assert_equal(path, exec[:path], "string-based path did not match")
         assert_nothing_raised("Could not use a colon-separated strings in an array for the path") do
-            exec = Puppet::Type.type(:exec).create(:command => "echo yay",
+            exec = Puppet::Type.type(:exec).new(:command => "echo yay",
                 :path => ["/usr/bin", "/usr/sbin:/sbin"])
         end
         assert_equal(path, exec[:path], "colon-separated array path did not match")
@@ -687,7 +684,7 @@ and stuff"
     def test_checks_apply_to_refresh
         file = tempfile()
         maker = tempfile()
-        exec = Puppet::Type.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :title => "maker",
             :command => "touch #{maker}",
             :path => ENV["PATH"]
@@ -726,7 +723,7 @@ and stuff"
     def test_explicit_refresh
         refresher = tempfile()
         maker = tempfile()
-        exec = Puppet::Type.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :title => "maker",
             :command => "touch #{maker}",
             :path => ENV["PATH"]
@@ -756,8 +753,8 @@ and stuff"
 
     if Puppet.features.root?
         def test_autorequire_user
-            user = Puppet::Type.type(:user).create(:name => "yay")
-            exec = Puppet::Type.type(:exec).create(:command => "/bin/echo fun", :user => "yay")
+            user = Puppet::Type.type(:user).new(:name => "yay")
+            exec = Puppet::Type.type(:exec).new(:command => "/bin/echo fun", :user => "yay")
 
             rels = nil
             assert_nothing_raised("Could not evaluate autorequire") do