puppet 0.16.0 → 0.18.4

data/test/types/type.rb

@@ -285,6 +285,185 @@ class TestType < Test::Unit::TestCase
             assert_nil(klass[obj.name], "object %s was not removed" % obj.name)
         end
     end
+
+    # Verify that objects can't be their own children.
+    def test_object_recursion
+        comp = Puppet.type(:component).create(:name => "top")
+
+        file = Puppet.type(:file).create(:path => tempfile, :ensure => :file)
+
+        assert_raise(Puppet::DevError) do
+            comp.push(comp)
+        end
+
+        assert_raise(Puppet::DevError) do
+            file.push(file)
+        end
+
+        assert_raise(Puppet::DevError) do
+            comp.parent = comp
+        end
+
+        assert_raise(Puppet::DevError) do
+            file.parent = file
+        end
+
+        assert_nothing_raised {
+            comp.push(file)
+        }
+
+        assert_raise(Puppet::DevError) do
+            file.push(comp)
+        end
+
+        assert_raise(Puppet::DevError) do
+            comp.parent = file
+        end
+    end
+
+    def test_loadplugins
+        names = %w{loadedplugin1 loadplugin2 loadplugin3}
+        dirs = []
+        3.times { dirs << tempfile() }
+        # Set plugindest to something random
+        Puppet[:plugindest] = tempfile()
+
+        Puppet[:pluginpath] = dirs.join(":")
+
+        names.each do |name|
+            dir = dirs.shift
+            Dir.mkdir(dir)
+
+            # Create an extra file for later
+            [name, name + "2ness"].each do |n|
+                file = File.join(dir, n + ".rb")
+                File.open(file, "w") do |f|
+                    f.puts %{Puppet::Type.newtype('#{n}') do
+    newparam(:argument) do
+        isnamevar
+    end
+end
+}
+                end
+            end
+
+            assert(Puppet::Type.type(name),
+                "Did not get loaded plugin")
+
+            assert_nothing_raised {
+                Puppet::Type.type(name).create(
+                    :name => "myname"
+                )
+            }
+        end
+
+        # Now make sure the plugindest got added to our pluginpath
+        assert(Puppet[:pluginpath].split(":").include?(Puppet[:plugindest]),
+            "Plugin dest did not get added to plugin path")
+
+        # Now make sure it works with just a single path, using the extra files
+        # created above.
+        Puppet[:pluginpath] = Puppet[:pluginpath].split(":")[0]
+        assert(Puppet::Type.type("loadedplugin12ness"),
+            "Did not get loaded plugin")
+
+    end
+
+    def test_newtype_methods
+        assert_nothing_raised {
+            Puppet::Type.newtype(:mytype) do
+                newparam(:wow) do isnamevar end
+            end
+        }
+
+        assert(Puppet::Type.respond_to?(:newmytype),
+            "new<type> method did not get created")
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet::Type.newmytype(:wow => "yay")
+        }
+
+        assert(obj.is_a?(Puppet::Type.type(:mytype)),
+            "Obj is not the correct type")
+
+        # Now make the type again, just to make sure it works on refreshing.
+        assert_nothing_raised {
+            Puppet::Type.newtype(:mytype) do
+                newparam(:yay) do isnamevar end
+            end
+        }
+
+        obj = nil
+        # Make sure the old class was thrown away and only the new one is sitting
+        # around.
+        assert_raise(Puppet::Error) {
+            obj = Puppet::Type.newmytype(:wow => "yay")
+        }
+        assert_nothing_raised {
+            obj = Puppet::Type.newmytype(:yay => "yay")
+        }
+
+        # Now make sure that we don't replace existing, non-type methods
+        parammethod = Puppet::Type.method(:newparam)
+
+        assert_nothing_raised {
+            Puppet::Type.newtype(:param) do
+                newparam(:rah) do isnamevar end
+            end
+        }
+        assert_equal(parammethod, Puppet::Type.method(:newparam),
+            "newparam method got replaced by newtype")
+    end
+
+    def test_notify_metaparam
+        file = Puppet::Type.newfile(
+            :path => tempfile(),
+            :notify => ["exec", "notifytest"],
+            :ensure => :file
+        )
+
+        path = tempfile()
+        exec = Puppet::Type.newexec(
+            :name => "notifytest",
+            :path => "/usr/bin:/bin",
+            :command => "touch #{path}",
+            :refreshonly => true
+        )
+
+        assert_apply(file, exec)
+
+        assert(exec.requires?(file),
+            "Notify did not correctly set up the requirement chain.")
+
+        assert(FileTest.exists?(path),
+            "Exec path did not get created.")
+    end
+
+    def test_before_metaparam
+        file = Puppet::Type.newfile(
+            :path => tempfile(),
+            :before => ["exec", "beforetest"],
+            :content => "yaytest"
+        )
+
+        path = tempfile()
+        exec = Puppet::Type.newexec(
+            :name => "beforetest",
+            :command => "/bin/cp #{file[:path]} #{path}"
+        )
+
+        assert_apply(file, exec)
+
+        assert(exec.requires?(file),
+            "Before did not correctly set up the requirement chain.")
+
+        assert(FileTest.exists?(path),
+            "Exec path did not get created.")
+
+        assert_equal("yaytest", File.read(path),
+            "Exec did not correctly copy file.")
+    end
 end
 
-# $Id: type.rb 1053 2006-04-02 23:39:02Z luke $
+# $Id: type.rb 1422 2006-07-22 03:32:56Z luke $

data/test/types/user.rb

@@ -4,7 +4,7 @@ if __FILE__ == $0
     $puppetbase = "../../../../language/trunk"
 end
 
-# $Id: user.rb 1042 2006-03-22 21:56:49Z luke $
+# $Id: user.rb 1422 2006-07-22 03:32:56Z luke $
 
 require 'etc'
 require 'puppet/type'
@@ -340,15 +340,22 @@ class TestUser < Test::Unit::TestCase
             user.retrieve
         }
 
-        assert(user.state(:groups).is, "Did not retrieve group list")
+        # Some tests to verify that groups work correctly startig from nothing
+        # Remove our user
+        user[:ensure] = :absent
+        assert_apply(user)
 
-        assert(!user.insync?, "User is incorrectly in sync")
+        assert_nothing_raised do
+            user.retrieve
+        end
 
-        assert_events([:user_modified], user)
+        # And add it again
+        user[:ensure] = :present
+        assert_apply(user)
 
-        assert_nothing_raised {
-            user.retrieve
-        }
+        user.retrieve
+
+        assert(user.state(:groups).is, "Did not retrieve group list")
 
         list = user.state(:groups).is
         assert_equal(extra.sort, list.sort, "Group list is not equal")
@@ -366,7 +373,7 @@ class TestUser < Test::Unit::TestCase
 
         assert(!user.insync?, "User is incorrectly in sync")
 
-        assert_events([:user_modified], user)
+        assert_apply(user)
 
         assert_nothing_raised {
             user.retrieve
@@ -444,6 +451,33 @@ class TestUser < Test::Unit::TestCase
         assert_equal(Process.uid, user.is(:uid), "Retrieved UID does not match")
     end
 
+    def test_autorequire
+        file = tempfile()
+        user = Puppet.type(:user).create(
+            :name => "pptestu",
+            :home => file,
+            :gid => "pptestg",
+            :groups => "yayness"
+        )
+        home = Puppet.type(:file).create(
+            :path => file,
+            :ensure => "directory"
+        )
+        group = Puppet.type(:group).create(
+            :name => "pptestg"
+        )
+        ogroup = Puppet.type(:group).create(
+            :name => "yayness"
+        )
+        comp = newcomp(user, group, home, ogroup)
+        comp.finalize
+        comp.retrieve
+
+        assert(user.requires?(group), "User did not require group")
+        assert(user.requires?(home), "User did not require home dir")
+        assert(user.requires?(ogroup), "User did not require other groups")
+    end
+
     if Process.uid == 0
         def test_simpleuser
             name = "pptest"
@@ -487,6 +521,7 @@ class TestUser < Test::Unit::TestCase
             tests = Puppet.type(:user).validstates
 
             tests.each { |test|
+                next unless test.to_s =~ /groups/
                 if self.respond_to?("attrtest_%s" % test)
                     self.send("attrtest_%s" % test, user)
                 else
@@ -498,26 +533,29 @@ class TestUser < Test::Unit::TestCase
             assert_apply(user)
         end
 
-        def test_autorequire
-            file = tempfile()
-            user = Puppet.type(:user).create(
-                :name => "pptestu",
-                :home => file,
-                :gid => "pptestg"
-            )
-            home = Puppet.type(:file).create(
-                :path => file,
-                :ensure => "directory"
-            )
-            group = Puppet.type(:group).create(
-                :name => "pptestg"
-            )
-            comp = newcomp(user, group)
-            comp.finalize
-            comp.retrieve
+        def test_duplicateIDs
+            user1 = mkuser("user1")
+            user1[:uid] = 125
+            user2 = mkuser("user2")
+            user2[:uid] = 125
+
+            cleanup do
+                user1[:ensure] = :absent
+                user2[:ensure] = :absent
+                assert_apply(user1, user2)
+            end
 
-            assert(user.requires?(group), "User did not require group")
-            assert(user.requires?(home), "User did not require home dir")
+            assert_apply(user1)
+
+            # 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[:allowdupe] = true
+            }
+            assert_apply(user2)
+            user2.retrieve
+            assert_equal(:present, user2.state(:ensure).is,
+                         "User did not get created")
         end
     else
         $stderr.puts "Not root; skipping user creation/modification tests"

data/test/types/yumrepo.rb

@@ -63,6 +63,21 @@ class TestYumRepo < Test::Unit::TestCase
         assert_equal(CREATE_EXP, text)
     end
 
+    # Delete mirrorlist by setting it to :absent and enable baseurl
+    def test_absent
+        copy_datafiles
+        baseurl = 'http://example.com/'
+        devel = make_repo("development", 
+                          { :mirrorlist => 'absent',
+                            :baseurl => baseurl })
+        devel.retrieve
+        assert_apply(devel)
+        inifile = Puppet.type(:yumrepo).read()
+        sec = inifile["development"]
+        assert_nil(sec["mirrorlist"])
+        assert_equal(baseurl, sec["baseurl"])
+    end
+
     def make_repo(name, hash={})
         hash[:name] = name
         Puppet.type(:yumrepo).create(hash)

data/test/types/zone.rb

@@ -0,0 +1,437 @@
+# Test host job creation, modification, and destruction
+
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppettest'
+require 'puppet'
+require 'puppet/type/zone'
+require 'test/unit'
+require 'facter'
+
+class TestZone < Test::Unit::TestCase
+	include TestPuppet
+
+    def test_nothing
+    end
+
+    # Zones can only be tested on solaris.
+    if Facter["operatingsystem"].value == "Solaris"
+
+    def setup
+        super
+        @@zones = []
+    end
+
+    def teardown
+        current = %x{zoneadm list -cp}.split("\n").inject({}) { |h, line|
+            ary = line.split(":")
+            h[ary[1]] = ary[2]
+            h
+        }
+
+        Puppet::Type.type(:zone).clear
+
+        # Get rid of any lingering zones
+        @@zones.each do |zone|
+            next unless current.include? zone
+
+            obj = Puppet::Type.type(:zone).create(:name => zone)
+            obj[:ensure] = :absent
+            assert_apply(obj)
+        end
+
+        # We can't delete the temp files until the zones are stopped and removed.
+        super
+    end
+
+    def mkzone(name)
+        zone = nil
+
+        base = tempfile()
+        Dir.mkdir(base)
+        File.chmod(0700, base)
+        root = File.join(base, "zonebase")
+        assert_nothing_raised {
+            zone = Puppet::Type.type(:zone).create(
+                :name => name,
+                :path => root,
+                :ensure => "configured" # don't want to install zones automatically
+            )
+        }
+
+        @@zones << name
+
+        return zone
+    end
+
+    def test_list
+        list = nil
+        assert_nothing_raised {
+            list = Puppet::Type.type(:zone).list
+        }
+
+        assert(! list.empty?, "Got no zones back")
+
+        assert(list.find { |z| z[:name] == "global" }, "Could not find global zone")
+    end
+
+    def test_valueslice
+        zone = mkzone("slicetest")
+
+        state = zone.state(:ensure)
+
+        slice = nil
+        assert_nothing_raised {
+            slice = state.class.valueslice(:absent, :installed).collect do |o|
+                o[:name]
+            end
+        }
+
+
+        assert_equal([:configured, :installed], slice)
+
+        assert_nothing_raised {
+            slice = state.class.valueslice(:running, :installed).collect do |o|
+                o[:name]
+            end
+        }
+
+
+        assert_equal(slice, [:installed])
+
+    end
+
+    # Make sure the ensure stuff behaves as we expect
+    def test_zoneensure
+        zone = mkzone("ensurezone")
+
+        state = zone.state(:ensure)
+
+        assert(state, "Did not get ensure state")
+
+        assert_nothing_raised {
+            zone.retrieve
+        }
+
+        assert(! state.insync?, "State is somehow in sync")
+
+        assert(state.up?, "State incorrectly thinks it is not moving up")
+
+        zone.is = [:ensure, :configured]
+        zone[:ensure] = :installed
+        assert(state.up?, "State incorrectly thinks it is not moving up")
+        zone[:ensure] = :absent
+        assert(! state.up?, "State incorrectly thinks it is moving up")
+    end
+
+    # Make sure all mentioned methods actually exist.
+    def test_zonemethods_exist
+        methods = []
+        zone = mkzone("methodtest")
+
+        state = zone.state(:ensure)
+        assert_nothing_raised {
+            state.class.valueslice(:absent, :running).each do |st|
+                [:up, :down].each do |m|
+                    if st[m]
+                        methods << st[m]
+                    end
+                end
+            end
+        }
+
+        methods.each do |m|
+            assert(Puppet::Type.type(:zone).method_defined?(m),
+                "Zones do not define method %s" % m)
+        end
+
+    end
+
+    # Make sure our state generates the correct text.
+    def test_inherit_state
+        zone = mkzone("configtesting")
+        zone[:ensure] = :configured
+
+        assert_nothing_raised {
+            zone[:inherit] = "/usr"
+        }
+        state = zone.state(:inherit)
+        assert(zone, "Did not get 'inherit' state")
+
+        assert_equal("add inherit-pkg-dir\nset dir=/usr\nend", state.configtext,
+            "Got incorrect config text")
+
+        state.is = "/usr"
+
+        assert_equal("", state.configtext,
+            "Got incorrect config text")
+
+        # Now we want multiple directories
+        state.should = %w{/usr /sbin /lib}
+
+        # The statements are sorted
+        text = "add inherit-pkg-dir
+set dir=/lib
+end
+add inherit-pkg-dir
+set dir=/sbin
+end"
+
+        assert_equal(text, state.configtext,
+            "Got incorrect config text")
+
+        state.is = %w{/usr /sbin /lib}
+        state.should = %w{/usr /sbin}
+
+        text = "remove inherit-pkg-dir dir=/lib"
+
+        assert_equal(text, state.configtext,
+            "Got incorrect config text")
+    end
+
+    if Process.uid == 0
+    # Make sure our ensure process actually works.
+    def test_ensure_sync
+        zone = mkzone("ensuretesting")
+
+        zone[:ensure] = :configured
+
+        zone.retrieve
+        assert_apply(zone)
+
+        zone.retrieve
+
+        assert(zone.insync?, "Zone is not insync")
+    end
+
+    def test_getconfig
+        zone = mkzone("configtesting")
+
+        base = tempfile()
+        zone[:path] = base
+
+        ip = "192.168.0.1"
+        interface = "bge0"
+        zone[:ip] = "#{interface}:#{ip}"
+
+        IO.popen("zonecfg -z configtesting -f -", "w") do |f|
+            f.puts %{create -b
+set zonepath=#{tempfile()}
+set autoboot=true
+add inherit-pkg-dir
+set dir=/lib
+end
+add inherit-pkg-dir
+set dir=/platform
+end
+add inherit-pkg-dir
+set dir=/sbin
+end
+add inherit-pkg-dir
+set dir=/opt/csw
+end
+add inherit-pkg-dir
+set dir=/usr
+end
+add net
+set address=#{ip}
+set physical=bge0
+end
+}
+        end
+
+        assert_equal(0, $?, "Did not successfully create zone")
+
+        #@@zones << "configtesting"
+
+        assert_nothing_raised {
+            zone.send(:getconfig)
+        }
+
+        # Now, make sure everything is right.
+        assert_equal(%w{/sbin /usr /opt/csw /lib /platform}.sort,
+            zone.is(:inherit).sort, "Inherited dirs did not get collected correctly."
+        )
+
+        assert_equal(["#{interface}:#{ip}"], zone.is(:ip),
+            "IP addresses did not get collected correctly.")
+
+        assert_equal(:true, zone.is(:autoboot),
+            "Autoboot did not get collected correctly.")
+    end
+
+    # Make sure we can do all the various and sundry configuring things.
+    def test_configuring_zones
+        zone = mkzone("configtesting")
+
+        assert_nothing_raised {
+            zone[:inherit] = "/usr"
+        }
+
+        zone[:ensure] = :configured
+
+        zone.retrieve
+        assert_apply(zone)
+
+        zone.retrieve
+
+        assert(zone.insync?, "Zone is not insync")
+
+        # Now add a new directory to inherit
+        assert_nothing_raised {
+            zone[:inherit] = ["/sbin", "/usr"]
+        }
+        assert_apply(zone)
+
+        zone.retrieve
+
+        assert(zone.insync?, "Zone is not insync")
+
+        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /dir: \/sbin/,
+            "sbin was not added")
+
+        # And then remove it.
+        assert_nothing_raised {
+            zone[:inherit] = "/usr"
+        }
+        assert_apply(zone)
+
+        zone.retrieve
+
+        assert(zone.insync?, "Zone is not insync")
+
+        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} !~ /dir: \/sbin/,
+            "sbin was not removed")
+
+        # Now add an ip adddress.  Fortunately (or not), zonecfg doesn't verify
+        # that the interface exists.
+        zone[:ip] = "hme0:192.168.0.1"
+
+        zone.retrieve
+        assert(! zone.insync?, "Zone is marked as in sync")
+
+        assert_apply(zone)
+        zone.retrieve
+        assert(zone.insync?, "Zone is not in sync")
+        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /192.168.0.1/,
+            "ip was not added")
+        zone[:ip] = ["hme1:192.168.0.2", "hme0:192.168.0.1"]
+        assert_apply(zone)
+        zone.retrieve
+        assert(zone.insync?, "Zone is not in sync")
+        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /192.168.0.2/,
+            "ip was not added")
+        zone[:ip] = ["hme1:192.168.0.2"]
+        assert_apply(zone)
+        zone.retrieve
+        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} !~ /192.168.0.1/,
+            "ip was not removed")
+    end
+
+    # Test creating and removing a zone, but only up to the configured state,
+    # so it's faster.
+    def test_smallcreate
+        zone = mkzone("smallcreate")
+        # Include a bunch of stuff so the zone isn't as large
+        dirs = %w{/usr /sbin /lib /platform}
+
+        %w{/opt/csw}.each do |dir|
+            dirs << dir if FileTest.exists? dir
+        end
+        zone[:inherit] = dirs
+
+        assert(zone, "Did not make zone")
+
+        zone[:ensure] = :configured
+
+        assert(! zone.insync?, "Zone is incorrectly in sync")
+
+        assert_apply(zone)
+
+        assert_nothing_raised {
+            zone.retrieve
+        }
+        assert(zone.insync?, "Zone is incorrectly out of sync")
+
+        zone[:ensure] = :absent
+
+        assert_apply(zone)
+
+        zone.retrieve
+
+        assert_equal(:absent, zone.is(:ensure), "Zone is not absent")
+    end
+
+    # Just go through each method linearly and make sure it works.
+    def test_each_method
+        zone = mkzone("methodtesting")
+        dirs = %w{/usr /sbin /lib /platform}
+
+        %w{/opt/csw}.each do |dir|
+            dirs << dir if FileTest.exists? dir
+        end
+        zone[:inherit] = dirs
+
+        [[:configure, :configured],
+            [:install, :installed],
+            [:start, :running],
+            [:stop, :installed],
+            [:uninstall, :configured],
+            [:unconfigure, :absent]
+        ].each do |method, state|
+            Puppet.info "Testing %s" % method
+            assert_nothing_raised {
+                zone.retrieve
+            }
+            assert_nothing_raised {
+                zone.send(method)
+            }
+            assert_nothing_raised {
+                zone.retrieve
+            }
+            assert_equal(state, zone.is(:ensure),
+                "Method %s did not correctly set state %s" %
+                    [method, state])
+        end
+    end
+
+    def test_mkzone
+        zone = mkzone("testmaking")
+        # Include a bunch of stuff so the zone isn't as large
+        dirs = %w{/usr /sbin /lib /platform}
+
+        %w{/opt/csw}.each do |dir|
+            dirs << dir if FileTest.exists? dir
+        end
+        zone[:inherit] = dirs
+
+        assert(zone, "Did not make zone")
+
+
+        [:configured, :installed, :running, :installed, :absent].each do |value|
+            assert_nothing_raised {
+                zone[:ensure] = value
+            }
+            assert(! zone.insync?, "Zone is incorrectly in sync")
+
+            assert_apply(zone)
+
+            assert_nothing_raised {
+                zone.retrieve
+            }
+            assert(zone.insync?, "Zone is incorrectly out of sync")
+        end
+
+        zone.retrieve
+
+        assert_equal(:absent, zone.is(:ensure), "Zone is not absent")
+    end
+    end
+    end
+end
+
+# $Id: zone.rb 1329 2006-06-28 18:51:11Z luke $