puppet 0.13.1 → 0.13.2

data/test/test

@@ -16,31 +16,38 @@ require 'getoptlong'
 	#[ "--size",	"-s",			GetoptLong::REQUIRED_ARGUMENT ],
 result = GetoptLong.new(
 	[ "--debug",	"-d",			GetoptLong::NO_ARGUMENT ],
+	[ "-n",			                GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--help",		"-h",			GetoptLong::NO_ARGUMENT ]
 )
 
 usage = "USAGE: %s [--help] <testsuite> <testsuite> .." % $0
 
+opts = []
+
 result.each { |opt,arg|
 	case opt
 		when "--debug"
-            Puppet[:debug] = true
+            Puppet::Log.level = :debug
 		when "--help"
 			puts usage
 			exit
 		else
-			raise "Invalid option '#{opt}'"
+            opts << opt << arg
+			#raise "Invalid option '#{opt}'"
 	end
 }
-
 suites = nil
 
 if ARGV.length != 0
-    suites = ARGV
+    suites = ARGV.dup
 else
     suites = PuppetTestSuite.list
 end
 
+ARGV.clear
+
+opts.each { |o| ARGV << o }
+
 suites.each { |suite|
     PuppetTestSuite.new(suite)
 }
@@ -48,4 +55,4 @@ suites.each { |suite|
 # This damn problem just doesn't seem to want to go away
 system("%s/etc/init.d/sleeper stop 2>/dev/null 1>/dev/null" % $puppetbase)
 
-# $Id: test 750 2005-11-22 05:34:43Z luke $
+# $Id: test 915 2006-02-15 21:56:54Z luke $

data/test/types/cron.rb

@@ -362,6 +362,26 @@ class TestCron < Test::Unit::TestCase
         cron.retrieve
         assert_events([], cron)
     end
+
+    def test_fieldremoval
+        cron = nil
+        assert_nothing_raised {
+            cron = Puppet.type(:cron).create(
+                :command => "/bin/date > /dev/null",
+                :minute => [0, 30],
+                :name => "crontest"
+            )
+        }
+
+        assert_events([:cron_created], cron)
+
+        cron[:minute] = :absent
+        assert_events([:cron_changed], cron)
+        assert_nothing_raised {
+            cron.retrieve
+        }
+        assert_equal(:absent, cron.is(:minute))
+    end
 end
 
-# $Id: cron.rb 899 2006-02-13 17:48:33Z luke $
+# $Id: cron.rb 910 2006-02-15 07:20:36Z luke $

data/test/types/exec.rb

@@ -9,7 +9,7 @@ require 'puppettest'
 require 'test/unit'
 require 'facter'
 
-# $Id: exec.rb 832 2006-01-17 07:11:50Z luke $
+# $Id: exec.rb 907 2006-02-13 21:58:40Z luke $
 
 class TestExec < Test::Unit::TestCase
 	include TestPuppet
@@ -255,7 +255,7 @@ class TestExec < Test::Unit::TestCase
         Puppet::Type.finalize
 
         # Verify we get the script itself
-        assert(exec.requires?(file), "Exec did not autorequire file")
+        assert(exec.requires?(file), "Exec did not autorequire %s" % file)
 
         # Verify we catch the cwd
         assert(exec.requires?(baseobj), "Exec did not autorequire cwd")
@@ -268,6 +268,50 @@ class TestExec < Test::Unit::TestCase
         assert(cat.requires?(file), "Exec did not catch inline file")
     end
 
+    def test_ifonly
+        afile = tempfile()
+        bfile = tempfile()
+
+        exec = nil
+        assert_nothing_raised {
+            exec = Puppet.type(:exec).create(
+                :command => "touch %s" % bfile,
+                :onlyif => "test -f %s" % afile,
+                :path => ENV['PATH']
+            )
+        }
+
+        assert_events([], exec)
+        system("touch %s" % afile)
+        assert_events([:executed_command], exec)
+        assert_events([:executed_command], exec)
+        system("rm %s" % afile)
+        assert_events([], exec)
+    end
+
+    def test_unless
+        afile = tempfile()
+        bfile = tempfile()
+
+        exec = nil
+        assert_nothing_raised {
+            exec = Puppet.type(:exec).create(
+                :command => "touch %s" % bfile,
+                :unless => "test -f %s" % afile,
+                :path => ENV['PATH']
+            )
+        }
+
+        assert_events([:executed_command], exec)
+        assert_events([:executed_command], exec)
+        system("touch %s" % afile)
+        assert_events([], exec)
+        assert_events([], exec)
+        system("rm %s" % afile)
+        assert_events([:executed_command], exec)
+        assert_events([:executed_command], exec)
+    end
+
     if Process.uid == 0
         # Verify that we can execute commands as a special user
         def mknverify(file, user, group = nil, id = true)

data/test/types/group.rb

@@ -4,7 +4,7 @@ if __FILE__ == $0
     $puppetbase = "../../../../language/trunk"
 end
 
-# $Id: group.rb 831 2006-01-16 20:01:20Z luke $
+# $Id: group.rb 914 2006-02-15 21:04:14Z luke $
 
 require 'etc'
 require 'puppet/type'
@@ -214,6 +214,18 @@ class TestGroup < Test::Unit::TestCase
         assert_equal(Process.gid, user.is(:gid), "Retrieved UID does not match")
     end
 
+    def test_ensurevals
+        gobj = nil
+        assert_nothing_raised {
+            gobj = Puppet.type(:group).create(
+                :name => name,
+                :ensure => :exists
+            )
+        }
+
+        assert_equal(false, gobj.state(:ensure))
+    end
+
     if Process.uid == 0
         def test_mkgroup
             gobj = nil
@@ -234,10 +246,10 @@ class TestGroup < Test::Unit::TestCase
                 #}
             #end
             assert(missing?(name), "Group %s is still present" % name)
-
             assert_nothing_raised {
                 gobj = Puppet.type(:group).create(
-                    :name => name
+                    :name => name,
+                    :ensure => :present
                 )
 
                 comp = newcomp("groupmaker %s" % name, gobj)

data/test/types/host.rb

@@ -33,12 +33,17 @@ class TestHost < Test::Unit::TestCase
     end
 
     def mkhost
+        if defined? @hcount
+            @hcount += 1
+        else
+            @hcount = 1
+        end
         host = nil
         assert_nothing_raised {
             host = Puppet.type(:host).create(
-                :name => "culain",
-                :ip => "192.168.0.3",
-                :alias => "puppet"
+                :name => "fakehost%s" % @hcount,
+                :ip => "192.168.27.%s" % @hcount,
+                :alias => "alias%s" % @hcount
             )
         }
 
@@ -141,6 +146,40 @@ class TestHost < Test::Unit::TestCase
         host.retrieve
         assert_events([], host)
     end
+
+    def test_modifyingfile
+        hostfile = tempfile()
+        Puppet.type(:host).path = hostfile
+
+        hosts = []
+        names = []
+        3.times {
+            h = mkhost()
+            #h[:ensure] = :present
+            #h.retrieve
+            hosts << h
+            names << h.name
+        }
+        assert_apply(*hosts)
+        hosts.clear
+        Puppet.type(:host).clear
+        newhost = mkhost()
+        #newhost[:ensure] = :present
+        names << newhost.name
+        assert_apply(newhost)
+        Puppet.type(:host).clear
+        # Verify we can retrieve that info
+        assert_nothing_raised("Could not retrieve after second write") {
+            newhost.retrieve
+        }
+
+        # And verify that we have data for everything
+        names.each { |name|
+            host = Puppet.type(:host)[name]
+            assert(host)
+            assert(host[:ip])
+        }
+    end
 end
 
-# $Id: host.rb 831 2006-01-16 20:01:20Z luke $
+# $Id: host.rb 910 2006-02-15 07:20:36Z luke $

data/test/types/port.rb

@@ -29,19 +29,25 @@ class TestPort < Test::Unit::TestCase
     # Here we just create a fake host type that answers to all of the methods
     # but does not modify our actual system.
     def mkfaketype
-        @faketype = Puppet::FileType.filetype(:ram)
-        @porttype.filetype = @faketype
+        pfile = tempfile()
+        @porttype.path = pfile
     end
 
     def mkport
         port = nil
+
+        if defined? @pcount
+            @pcount += 1
+        else
+            @pcount = 1
+        end
         assert_nothing_raised {
             port = Puppet.type(:port).create(
-                :name => "puppet",
-                :number => "8139",
+                :name => "puppet%s" % @pcount,
+                :number => "813%s" % @pcount,
                 :protocols => "tcp",
                 :description => "The port that Puppet runs on",
-                :alias => "coolness"
+                :alias => "coolness%s" % @pcount
             )
         }
 
@@ -134,6 +140,61 @@ class TestPort < Test::Unit::TestCase
         port.retrieve
         assert_events([], port)
     end
+
+    def test_modifyingfile
+        mkfaketype()
+
+        ports = []
+        names = []
+        3.times {
+            k = mkport()
+            ports << k
+            names << k.name
+        }
+        assert_apply(*ports)
+        ports.clear
+        Puppet.type(:port).clear
+        newport = mkport()
+        #newport[:ensure] = :present
+        names << newport.name
+        assert_apply(newport)
+        Puppet.type(:port).clear
+        # Verify we can retrieve that info
+        assert_nothing_raised("Could not retrieve after second write") {
+            newport.retrieve
+        }
+
+        # And verify that we have data for everything
+        names.each { |name|
+            port = Puppet.type(:port)[name]
+            assert(port)
+            port.retrieve
+            assert(port[:number], "port %s has no number" % name)
+        }
+    end
+
+    def test_addingstates
+        mkfaketype
+
+        port = mkport()
+        assert_events([:port_created], port)
+
+        port.delete(:alias)
+        assert(! port.state(:alias))
+        assert_events([:port_changed], port)
+        assert_nothing_raised {
+            port.retrieve
+        }
+
+        assert_equal(:present, port.is(:ensure))
+
+        assert(port.state(:alias).is == :absent)
+
+        port[:alias] = "yaytest"
+        assert_events([:port_changed], port)
+        port.retrieve
+        assert(port.state(:alias).is == ["yaytest"])
+    end
 end
 
-# $Id: port.rb 831 2006-01-16 20:01:20Z luke $
+# $Id: port.rb 915 2006-02-15 21:56:54Z luke $

data/test/types/sshkey.rb

@@ -35,12 +35,19 @@ class TestSSHKey < Test::Unit::TestCase
 
     def mkkey
         key = nil
+
+        if defined? @kcount
+            @kcount += 1
+        else
+            @kcount = 1
+        end
+
         assert_nothing_raised {
             key = @sshtype.create(
-                :name => "culain.madstop.com",
-                :key => "AAAAB3NzaC1kc3MAAACBAMnhSiku76y3EGkNCDsUlvpO8tRgS9wL4Eh54WZfQ2lkxqfd2uT/RTT9igJYDtm/+UHuBRdNGpJYW1Nw2i2JUQgQEEuitx4QKALJrBotejGOAWxxVk6xsh9xA0OW8Q3ZfuX2DDitfeC8ZTCl4xodUMD8feLtP+zEf8hxaNamLlt/AAAAFQDYJyf3vMCWRLjTWnlxLtOyj/bFpwAAAIEAmRxxXb4jjbbui9GYlZAHK00689DZuX0EabHNTl2yGO5KKxGC6Esm7AtjBd+onfu4Rduxut3jdI8GyQCIW8WypwpJofCIyDbTUY4ql0AQUr3JpyVytpnMijlEyr41FfIb4tnDqnRWEsh2H7N7peW+8DWZHDFnYopYZJ9Yu4/jHRYAAACAERG50e6aRRb43biDr7Ab9NUCgM9bC0SQscI/xdlFjac0B/kSWJYTGVARWBDWug705hTnlitY9cLC5Ey/t/OYOjylTavTEfd/bh/8FkAYO+pWdW3hx6p97TBffK0b6nrc6OORT2uKySbbKOn0681nNQh4a6ueR3JRppNkRPnTk5c=",
+                :name => "host%s.madstop.com" % @kcount,
+                :key => "%sAAAAB3NzaC1kc3MAAACBAMnhSiku76y3EGkNCDsUlvpO8tRgS9wL4Eh54WZfQ2lkxqfd2uT/RTT9igJYDtm/+UHuBRdNGpJYW1Nw2i2JUQgQEEuitx4QKALJrBotejGOAWxxVk6xsh9xA0OW8Q3ZfuX2DDitfeC8ZTCl4xodUMD8feLtP+zEf8hxaNamLlt/AAAAFQDYJyf3vMCWRLjTWnlxLtOyj/bFpwAAAIEAmRxxXb4jjbbui9GYlZAHK00689DZuX0EabHNTl2yGO5KKxGC6Esm7AtjBd+onfu4Rduxut3jdI8GyQCIW8WypwpJofCIyDbTUY4ql0AQUr3JpyVytpnMijlEyr41FfIb4tnDqnRWEsh2H7N7peW+8DWZHDFnYopYZJ9Yu4/jHRYAAACAERG50e6aRRb43biDr7Ab9NUCgM9bC0SQscI/xdlFjac0B/kSWJYTGVARWBDWug705hTnlitY9cLC5Ey/t/OYOjylTavTEfd/bh/8FkAYO+pWdW3hx6p97TBffK0b6nrc6OORT2uKySbbKOn0681nNQh4a6ueR3JRppNkRPnTk5c=" % @kcount,
                 :type => "ssh-dss",
-                :alias => ["192.168.0.3"]
+                :alias => ["192.168.0.%s" % @kcount]
             )
         }
 
@@ -135,6 +142,40 @@ class TestSSHKey < Test::Unit::TestCase
         sshkey.retrieve
         assert_events([], sshkey)
     end
+
+    def test_modifyingfile
+        keyfile = tempfile()
+        Puppet.type(:sshkey).path = keyfile
+
+        keys = []
+        names = []
+        3.times {
+            k = mkkey()
+            #h[:ensure] = :present
+            #h.retrieve
+            keys << k
+            names << k.name
+        }
+        assert_apply(*keys)
+        keys.clear
+        Puppet.type(:sshkey).clear
+        newkey = mkkey()
+        #newkey[:ensure] = :present
+        names << newkey.name
+        assert_apply(newkey)
+        Puppet.type(:sshkey).clear
+        # Verify we can retrieve that info
+        assert_nothing_raised("Could not retrieve after second write") {
+            newkey.retrieve
+        }
+
+        # And verify that we have data for everything
+        names.each { |name|
+            key = Puppet.type(:sshkey)[name]
+            assert(key)
+            assert(key[:type])
+        }
+    end
 end
 
-# $Id: sshkey.rb 831 2006-01-16 20:01:20Z luke $
+# $Id: sshkey.rb 910 2006-02-15 07:20:36Z luke $

data/test/types/symlink.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: symlink.rb 787 2006-01-08 00:02:23Z luke $
+# $Id: symlink.rb 905 2006-02-13 21:49:25Z luke $
 
 class TestSymlink < Test::Unit::TestCase
 	include FileTesting
@@ -38,8 +38,8 @@ class TestSymlink < Test::Unit::TestCase
 
     def newlink(hash = {})
         hash[:name] = tmplink()
-        unless hash.include?(:target)
-            hash[:target] = mktmpfile()
+        unless hash.include?(:ensure)
+            hash[:ensure] = mktmpfile()
         end
         link = Puppet.type(:symlink).create(hash)
         return link
@@ -71,7 +71,7 @@ class TestSymlink < Test::Unit::TestCase
 
         link = nil
         assert_nothing_raised {
-            link = newlink(:target => source, :recurse => true)
+            link = newlink(:ensure => source, :recurse => true)
         }
         comp = newcomp("linktest",link)
         cycle(comp)

data/test/types/type.rb

@@ -190,7 +190,14 @@ class TestType < Test::Unit::TestCase
     # Verify that names are aliases, not equivalents
     def test_nameasalias
         file = nil
-        path = tempfile()
+        # 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
@@ -209,8 +216,39 @@ class TestType < Test::Unit::TestCase
         assert_apply(file)
 
         assert(Puppet.type(:file)[name], "Could not look up object by name")
-        #assert(Puppet.type(:file)[path], "Could not look up object by path")
+    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.state(:ensure), "User got an ensure state")
+
+        assert_nothing_raised {
+            user = Puppet.type(:user).create(
+                :name => "pptestAA",
+                :comment => "Testingness"
+            )
+        }
+        # but make sure it gets added once we manage them
+        assert(user.state(:ensure), "User did not add ensure state")
+
+        assert_nothing_raised {
+            user = Puppet.type(:user).create(
+                :name => "pptestBB",
+                :comment => "A fake user"
+            )
+        }
+
+        # and make sure managed objects start with them
+        assert(user.state(:ensure), "User did not get an ensure state")
     end
 end
 
-# $Id: type.rb 896 2006-02-10 22:00:30Z luke $
+# $Id: type.rb 915 2006-02-15 21:56:54Z luke $