puppet 0.9.2 → 0.13.0

data/test/types/cron.rb

@@ -8,11 +8,18 @@ end
 
 require 'puppettest'
 require 'puppet'
-require 'puppet/type/cron'
 require 'test/unit'
 require 'facter'
 
-class TestExec < Test::Unit::TestCase
+
+# Here we just want to unit-test our cron type, to verify that 
+#class TestCronType < Test::Unit::TestCase
+#	include TestPuppet
+#
+#
+#end
+
+class TestCron < Test::Unit::TestCase
 	include TestPuppet
     def setup
         super
@@ -26,15 +33,24 @@ class TestExec < Test::Unit::TestCase
         unless defined? @me
             raise "Could not retrieve user name; 'id' did not work"
         end
+
         # god i'm lazy
-        @crontype = Puppet::Type::Cron
+        @crontype = Puppet.type(:cron)
+        @oldfiletype = @crontype.filetype
+        @fakefiletype = Puppet::FileType.filetype(:ram)
+        @crontype.filetype = @fakefiletype
+    end
+
+    def teardown
+        @crontype.filetype = @oldfiletype
+        super
     end
 
     # Back up the user's existing cron tab if they have one.
     def cronback
         tab = nil
         assert_nothing_raised {
-            tab = Puppet::Type::Cron.crontype.read(@me)
+            tab = Puppet.type(:cron).filetype.read(@me)
         }
 
         if $? == 0
@@ -48,9 +64,9 @@ class TestExec < Test::Unit::TestCase
     def cronrestore
         assert_nothing_raised {
             if @currenttab
-                @crontype.crontype.write(@me, @currenttab)
+                @crontype.filetype.new(@me).write(@currenttab)
             else
-                @crontype.crontype.remove(@me)
+                @crontype.filetype.new(@me).remove
             end
         }
     end
@@ -78,17 +94,21 @@ class TestExec < Test::Unit::TestCase
         name = cron.name
         comp = newcomp(name, cron)
 
-        trans = assert_events(comp, [:cron_created], name)
+        assert_events([:cron_created], comp)
+        cron.retrieve
+
+        assert(cron.insync?)
+
+        assert_events([], comp)
+
+        cron[:ensure] = :absent
+
+        assert_events([:cron_removed], comp)
+
         cron.retrieve
+
         assert(cron.insync?)
-        trans = assert_events(comp, [], name)
-        cron[:command] = :notfound
-        trans = assert_events(comp, [:cron_deleted], name)
-        # the cron should no longer exist, not even in the comp
-        trans = assert_events(comp, [], name)
-
-        assert(!comp.include?(cron),
-            "Cron is still a member of comp, after being deleted")
+        assert_events([], comp)
     end
 
     # A simple test to see if we can load the cron from disk.
@@ -107,18 +127,66 @@ class TestExec < Test::Unit::TestCase
         assert_nothing_raised {
             cron = @crontype.create(
                 :name => name,
-                :command => "date",
+                :command => "date > /dev/null",
                 :user => @me
             )
         }
         str = nil
         # generate the text
         assert_nothing_raised {
-            str = cron.to_cron
+            str = cron.to_record
         }
-        assert_equal(str, "# Puppet Name: #{name}\n* * * * * date",
+
+        assert_equal(str, "# Puppet Name: #{name}\n* * * * * date > /dev/null",
             "Cron did not generate correctly")
     end
+
+    # Test that changing any field results in the cron tab being rewritten.
+    # it directly
+    def test_any_field_changes
+        cron = nil
+        # make the cron
+        name = "yaytest"
+        assert_nothing_raised {
+            cron = @crontype.create(
+                :name => name,
+                :command => "date > /dev/null",
+                :month => "May",
+                :user => @me
+            )
+        }
+        assert(cron, "Cron did not get created")
+        comp = newcomp(cron)
+        assert_events([:cron_created], comp)
+
+        assert_nothing_raised {
+            cron[:month] = "June"
+        }
+
+        cron.retrieve
+
+        assert_events([:cron_changed], comp)
+    end
+
+    # Test that a cron job with spaces at the end doesn't get rewritten
+    def test_trailingspaces
+        cron = nil
+        # make the cron
+        name = "yaytest"
+        assert_nothing_raised {
+            cron = @crontype.create(
+                :name => name,
+                :command => "date > /dev/null ",
+                :month => "May",
+                :user => @me
+            )
+        }
+        comp = newcomp(cron)
+
+        assert_events([:cron_created], comp, "did not create cron job")
+        cron.retrieve
+        assert_events([], comp, "cron job got rewritten")
+    end
     
     # Test that comments are correctly retained
     def test_retain_comments
@@ -130,7 +198,7 @@ class TestExec < Test::Unit::TestCase
 
         assert_nothing_raised {
             newstr = @crontype.tab(user)
-            assert_equal(str, newstr, "Cron comments were changed or lost")
+            assert(newstr.include?(str), "Comments were lost")
         }
     end
 
@@ -156,62 +224,59 @@ class TestExec < Test::Unit::TestCase
 
         assert_nothing_raised {
             newstr = @crontype.tab(@me)
-            assert_equal(modstr, newstr, "Cron was not correctly matched")
+            assert(newstr.include?(modstr),
+                "Cron was not correctly matched")
         }
     end
 
     # Test adding a cron when there is currently no file.
     def test_mkcronwithnotab
-        cronback
-        Puppet::Type::Cron.crontype.remove(@me)
+        tab = @fakefiletype.new(@me)
+        tab.remove
 
         cron = mkcron("testwithnotab")
         cyclecron(cron)
-        cronrestore
     end
 
     def test_mkcronwithtab
-        cronback
-        Puppet::Type::Cron.crontype.remove(@me)
-        Puppet::Type::Cron.crontype.write(@me,
-"1 1 1 1 * date > %s/crontesting\n" % testdir()
+        tab = @fakefiletype.new(@me)
+        tab.remove
+        tab.write(
+"1 1 1 1 * date > %s/crontesting\n" % tstdir()
         )
 
         cron = mkcron("testwithtab")
         cyclecron(cron)
-        cronrestore
     end
 
     def test_makeandretrievecron
-        cronback
-        Puppet::Type::Cron.crontype.remove(@me)
+        tab = @fakefiletype.new(@me)
+        tab.remove
 
         name = "storeandretrieve"
         cron = mkcron(name)
         comp = newcomp(name, cron)
-        trans = assert_events(comp, [:cron_created], name)
+        trans = assert_events([:cron_created], comp, name)
         
         cron = nil
 
-        Puppet::Type::Cron.clear
-        Puppet::Type::Cron.retrieve(@me)
+        Puppet.type(:cron).retrieve(@me)
 
-        assert(cron = Puppet::Type::Cron[name], "Could not retrieve named cron")
-        assert_instance_of(Puppet::Type::Cron, cron)
-        cronrestore
+        assert(cron = Puppet.type(:cron)[name], "Could not retrieve named cron")
+        assert_instance_of(Puppet.type(:cron), cron)
     end
 
     # Do input validation testing on all of the parameters.
     def test_arguments
         values = {
             :monthday => {
-                :valid => [ 1, 13, "1,30" ],
+                :valid => [ 1, 13, "1" ],
                 :invalid => [ -1, 0, 32 ]
             },
             :weekday => {
-                :valid => [ 0, 3, 6, "1,2", "tue", "wed",
+                :valid => [ 0, 3, 6, "1", "tue", "wed",
                     "Wed", "MOnday", "SaTurday" ],
-                :invalid => [ -1, 7, "1, 3", "tues", "teusday", "thurs" ]
+                :invalid => [ -1, 7, "13", "tues", "teusday", "thurs" ]
             },
             :hour => {
                 :valid => [ 0, 21, 23 ],
@@ -223,14 +288,16 @@ class TestExec < Test::Unit::TestCase
             },
             :month => {
                 :valid => [ 1, 11, 12, "mar", "March", "apr", "October", "DeCeMbEr" ],
-                :invalid => [ 0, 13, "marc", "sept" ]
+                :invalid => [ -1, 0, 13, "marc", "sept" ]
             }
         }
 
         cron = mkcron("valtesting")
         values.each { |param, hash|
-            hash.each { |type, values|
-                values.each { |value|
+            # We have to test the valid ones first, because otherwise the
+            # state will fail to create at all.
+            [:valid, :invalid].each { |type|
+                hash[type].each { |value|
                     case type
                     when :valid:
                         assert_nothing_raised {
@@ -238,7 +305,7 @@ class TestExec < Test::Unit::TestCase
                         }
 
                         if value.is_a?(Integer)
-                            assert_equal([value], cron[param],
+                            assert_equal(value.to_s, cron.should(param),
                                 "Cron value was not set correctly")
                         end
                     when :invalid:
@@ -258,4 +325,4 @@ class TestExec < Test::Unit::TestCase
     end
 end
 
-# $Id: cron.rb 742 2005-11-16 17:12:11Z luke $
+# $Id: cron.rb 831 2006-01-16 20:01:20Z luke $

data/test/types/exec.rb

@@ -9,7 +9,7 @@ require 'puppettest'
 require 'test/unit'
 require 'facter'
 
-# $Id: exec.rb 742 2005-11-16 17:12:11Z luke $
+# $Id: exec.rb 832 2006-01-17 07:11:50Z luke $
 
 class TestExec < Test::Unit::TestCase
 	include TestPuppet
@@ -17,46 +17,29 @@ class TestExec < Test::Unit::TestCase
         command = nil
         output = nil
         assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
+            command = Puppet.type(:exec).create(
                 :command => "/bin/echo"
             )
         }
         assert_nothing_raised {
             command.evaluate
         }
-        assert_nothing_raised {
-            output = command.sync
-        }
-        assert_equal([:executed_command],output)
+        assert_events([:executed_command], command)
     end
 
     def test_numvsstring
-        command = nil
-        output = nil
-        assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
-                :command => "/bin/echo",
-                :returns => 0
-            )
-        }
-        assert_nothing_raised {
-            command.evaluate
-        }
-        assert_nothing_raised {
-            output = command.sync
-        }
-        Puppet::Type::Exec.clear
-        assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
-                :command => "/bin/echo",
-                :returns => "0"
-            )
-        }
-        assert_nothing_raised {
-            command.evaluate
-        }
-        assert_nothing_raised {
-            output = command.sync
+        [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 => "/bin/echo",
+                    :returns => val
+                )
+            }
+            assert_events([:executed_command], command)
         }
     end
 
@@ -64,27 +47,27 @@ class TestExec < Test::Unit::TestCase
         command = nil
         output = nil
         assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
+            command = Puppet.type(:exec).create(
                 :command => "echo"
             )
             assert_nil(command)
         }
-        Puppet::Type::Exec.clear
+        Puppet.type(:exec).clear
         assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
+            command = Puppet.type(:exec).create(
                 :command => "echo",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin"
             )
         }
-        Puppet::Type::Exec.clear
+        Puppet.type(:exec).clear
         assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
+            command = Puppet.type(:exec).create(
                 :command => "/bin/echo"
             )
         }
-        Puppet::Type::Exec.clear
+        Puppet.type(:exec).clear
         assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
+            command = Puppet.type(:exec).create(
                 :command => "/bin/echo",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin"
             )
@@ -93,21 +76,21 @@ class TestExec < Test::Unit::TestCase
 
     def test_nonzero_returns
         assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
+            command = Puppet.type(:exec).create(
                 :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(:exec).create(
                 :command => "touch /etc",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :returns => 1
             )
         }
         assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
+            command = Puppet.type(:exec).create(
                 :command => "thiscommanddoesnotexist",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :returns => 127
@@ -122,37 +105,33 @@ class TestExec < Test::Unit::TestCase
             Dir.getwd
         }
         assert_nothing_raised {
-            command = Puppet::Type::Exec.create(
+            command = Puppet.type(:exec).create(
                 :command => "pwd",
                 :cwd => dir,
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :returns => 0
             )
         }
-        assert_nothing_raised {
-            command.evaluate
-        }
-        assert_nothing_raised {
-            command.sync
-        }
+        assert_events([:executed_command], command)
         assert_equal(wd,command.output.chomp)
     end
 
     def test_refreshonly
         file = nil
         cmd = nil
-        tmpfile = "/tmp/exectesting"
+        tmpfile = tempfile()
         @@tmpfiles.push tmpfile
         trans = nil
         File.open(tmpfile, File::WRONLY|File::CREAT|File::TRUNC) { |of|
             of.puts rand(100)
         }
-        file = Puppet::Type::PFile.create(
+        file = Puppet.type(:file).create(
             :path => tmpfile,
             :checksum => "md5"
         )
+        assert_instance_of(Puppet.type(:file), file)
         assert_nothing_raised {
-            cmd = Puppet::Type::Exec.create(
+            cmd = Puppet.type(:exec).create(
                 :command => "pwd",
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :subscribe => [[file.class.name,file.name]],
@@ -160,7 +139,9 @@ class TestExec < Test::Unit::TestCase
             )
         }
 
-        comp = Puppet::Type::Component.create(:name => "RefreshTest")
+        assert_instance_of(Puppet.type(:exec), cmd)
+
+        comp = Puppet.type(:component).create(:name => "RefreshTest")
         [file,cmd].each { |obj|
             comp.push obj
         }
@@ -190,7 +171,7 @@ class TestExec < Test::Unit::TestCase
         # verify that only the file_changed event was kicked off, not the
         # command_executed
         assert_equal(
-            [:file_modified],
+            [:file_changed],
             events
         )
     end
@@ -198,8 +179,9 @@ class TestExec < Test::Unit::TestCase
     def test_creates
         file = tempfile()
         exec = nil
+        assert(! FileTest.exists?(file), "File already exists")
         assert_nothing_raised {
-            exec = Puppet::Type::Exec.create(
+            exec = Puppet.type(:exec).create(
                 :command => "touch %s" % file,
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
                 :creates => file
@@ -207,8 +189,83 @@ class TestExec < Test::Unit::TestCase
         }
 
         comp = newcomp("createstest", exec)
-        assert_events(comp, [:executed_command], "creates")
-        assert_events(comp, [], "creates")
+        assert_events([:executed_command], comp, "creates")
+        assert_events([], comp, "creates")
+    end
+
+    # Verify that we can download the file that we're going to execute.
+    def test_retrievethenmkexe
+        exe = tempfile()
+        oexe = tempfile()
+        sh = %x{which sh}
+        File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
+
+        file = Puppet.type(:file).create(
+            :name => oexe,
+            :source => exe,
+            :mode => 0755
+        )
+
+        exec = Puppet.type(:exec).create(
+            :name => oexe,
+            :require => [:file, oexe]
+        )
+
+        comp = newcomp("Testing", file, exec)
+
+        assert_events([:file_created, :executed_command], comp)
+    end
+
+    # Verify that we auto-require any managed scripts.
+    def test_autorequire
+        exe = tempfile()
+        oexe = tempfile()
+        sh = %x{which sh}
+        File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
+
+        file = Puppet.type(:file).create(
+            :name => oexe,
+            :source => exe,
+            :mode => 755
+        )
+
+        basedir = File.dirname(oexe)
+        baseobj = Puppet.type(:file).create(
+            :name => basedir,
+            :source => exe,
+            :mode => 755
+        )
+
+        ofile = Puppet.type(:file).create(
+            :name => exe,
+            :mode => 755
+        )
+
+        exec = Puppet.type(:exec).create(
+            :name => oexe,
+            :path => ENV["PATH"],
+            :cwd => basedir
+        )
+
+        cat = Puppet.type(:exec).create(
+            :name => "cat %s %s" % [exe, oexe],
+            :path => ENV["PATH"]
+        )
+
+        Puppet::Type.finalize
+
+        # Verify we get the script itself
+        assert(exec.requires?(file), "Exec did not autorequire file")
+
+        # Verify we catch the cwd
+        assert(exec.requires?(baseobj), "Exec did not autorequire cwd")
+
+        # Verify we don't require ourselves
+        assert(!exec.requires?(ofile), "Exec incorrectly required file")
+
+        # Verify that we catch inline files
+        assert(cat.requires?(ofile), "Exec did not catch second inline file")
+        assert(cat.requires?(file), "Exec did not catch inline file")
     end
 
     if Process.uid == 0
@@ -239,11 +296,11 @@ class TestExec < Test::Unit::TestCase
             end
             exec = nil
             assert_nothing_raised {
-                exec = Puppet::Type::Exec.create(args)
+                exec = Puppet.type(:exec).create(args)
             }
 
             comp = newcomp("usertest", exec)
-            assert_events(comp, [:executed_command], "usertest")
+            assert_events([:executed_command], comp, "usertest")
 
             assert(FileTest.exists?(file), "File does not exist")
             if user