puppet 0.18.4 → 0.22.4

data/test/ral/types/tidy.rb

@@ -0,0 +1,240 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+class TestTidy < Test::Unit::TestCase
+    include PuppetTest::FileTesting
+    def mktmpfile
+        # because luke's home directory is on nfs, it can't be used for testing
+        # as root
+        tmpfile = tempfile()
+        File.open(tmpfile, "w") { |f| f.puts rand(100) }
+        @@tmpfiles.push tmpfile
+        return tmpfile
+    end
+
+    def mktmpdir
+        dir = File.join(tmpdir(), "puppetlinkdir")
+        unless FileTest.exists?(dir)
+            Dir.mkdir(dir)
+        end
+        @@tmpfiles.push dir
+        return dir
+    end
+
+    def test_tidydirs
+        dir = mktmpdir
+        file = File.join(dir, "file")
+        File.open(file, "w") { |f|
+            f.puts "some stuff"
+        }
+
+        tidy = Puppet.type(:tidy).create(
+            :name => dir,
+            :size => "1b",
+            :rmdirs => true,
+            :recurse => true
+        )
+
+        assert_events([:file_tidied, :file_tidied], tidy)
+
+        assert(!FileTest.exists?(file), "Tidied %s still exists" % file)
+        assert(!FileTest.exists?(dir), "Tidied %s still exists" % dir)
+
+    end
+
+    def disabled_test_recursion
+        source = mktmpdir()
+        FileUtils.cd(source) {
+            mkranddirsandfiles()
+        }
+
+        link = nil
+        assert_nothing_raised {
+            link = newlink(:target => source, :recurse => true)
+        }
+        comp = newcomp("linktest",link)
+        cycle(comp)
+
+        path = link.name
+        list = file_list(path)
+        FileUtils.cd(path) {
+            list.each { |file|
+                unless FileTest.directory?(file)
+                    assert(FileTest.symlink?(file))
+                    target = File.readlink(file)
+                    assert_equal(target,File.join(source,file.sub(/^\.\//,'')))
+                end
+            }
+        }
+    end
+
+    # Test the different age iterations.
+    def test_age_conversions
+        tidy = Puppet::Type.newtidy :path => tempfile(), :age => "1m"
+
+        convertors = {
+            :second => 1,
+            :minute => 60
+        }
+
+        convertors[:hour] = convertors[:minute] * 60
+        convertors[:day] = convertors[:hour] * 24
+        convertors[:week] = convertors[:day] * 7
+
+        # First make sure we default to days
+        assert_nothing_raised do
+            tidy[:age] = "2"
+        end
+
+        assert_equal(2 * convertors[:day], tidy.should(:age),
+            "Converted 2 wrong")
+
+        convertors.each do |name, number|
+            init = name.to_s[0..0] # The first letter
+            [0, 1, 5].each do |multi|
+                [init, init.upcase].each do |letter|
+                    age = multi.to_s + letter.to_s
+                    assert_nothing_raised do
+                        tidy[:age] = age
+                    end
+
+                    assert_equal(multi * convertors[name], tidy.should(:age),
+                        "Converted %s wrong" % age)
+                end
+            end
+        end
+    end
+
+    def test_size_conversions
+        convertors = {
+            :b => 0,
+            :kb => 1,
+            :mb => 2,
+            :gb => 3
+        }
+
+        tidy = Puppet::Type.newtidy :path => tempfile(), :age => "1m"
+
+        # First make sure we default to kb
+        assert_nothing_raised do
+            tidy[:size] = "2"
+        end
+
+        assert_equal(2048, tidy.should(:size),
+            "Converted 2 wrong")
+
+        convertors.each do |name, number|
+            init = name.to_s[0..0] # The first letter
+            [0, 1, 5].each do |multi|
+                [init, init.upcase].each do |letter|
+                    size = multi.to_s + letter.to_s
+                    assert_nothing_raised do
+                        tidy[:size] = size
+                    end
+
+                    total = multi
+                    number.times do total *= 1024 end
+
+                    assert_equal(total, tidy.should(:size),
+                        "Converted %s wrong" % size)
+                end
+            end
+        end
+    end
+
+    def test_agetest
+        tidy = Puppet::Type.newtidy :path => tempfile(), :age => "1m"
+
+        age = tidy.property(:age)
+
+        # Set it to something that should be fine
+        age.is = Time.now.to_i - 5
+
+        assert(age.insync?, "Tried to tidy a low age")
+
+        # Now to something that should fail
+        age.is = Time.now.to_i - 120
+
+        assert(! age.insync?, "Incorrectly skipped tidy")
+    end
+
+    def test_sizetest
+        tidy = Puppet::Type.newtidy :path => tempfile(), :size => "1k"
+
+        size = tidy.property(:size)
+
+        # Set it to something that should be fine
+        size.is = 50
+
+        assert(size.insync?, "Tried to tidy a low size")
+
+        # Now to something that should fail
+        size.is = 2048
+
+        assert(! size.insync?, "Incorrectly skipped tidy")
+    end
+
+    # Make sure we can remove different types of files
+    def test_tidytypes
+        path = tempfile()
+        tidy = Puppet::Type.newtidy :path => path, :size => "1b", :age => "1s"
+
+        # Start with a file
+        File.open(path, "w") { |f| f.puts "this is a test" }
+        assert_events([:file_tidied], tidy)
+        assert(! FileTest.exists?(path), "File was not removed")
+
+        # Then a link
+        dest = tempfile
+        File.open(dest, "w") { |f| f.puts "this is a test" }
+        File.symlink(dest, path)
+        assert_events([:file_tidied], tidy)
+        assert(! FileTest.exists?(path), "Link was not removed")
+        assert(FileTest.exists?(dest), "Destination was removed")
+
+        # And a directory
+        Dir.mkdir(path)
+        tidy.is = [:ensure, [Time.now - 1024, 1]]
+        tidy[:rmdirs] = true
+        assert_events([:file_tidied], tidy)
+        assert(! FileTest.exists?(path), "File was not removed")
+    end
+    
+    # Make sure we can specify either attribute and get appropriate behaviour.
+    # I found that the original implementation of this did not work unless both
+    # size and age were specified.
+    def test_one_attribute
+        path = tempfile()
+        File.open(path, "w") { |f| 10.times { f.puts "yayness " } }
+        tidy = Puppet::Type.type(:tidy).create :path => path, :size => "1b"
+        
+        assert_apply(tidy)
+        assert(! FileTest.exists?(path), "file did not get tidied")
+        
+        # Now try one with just an age attribute.
+        File.open(path, "w") { |f| 10.times { f.puts "yayness " } }
+        tidy = Puppet::Type.type(:tidy).create :path => path, :age => "5s"
+        
+        tidy.property(:age).is = "0s"
+        assert_apply(tidy)
+        assert(! FileTest.exists?(path), "file did not get tidied")
+    end
+    
+    # Testing #355.
+    def test_remove_dead_links
+        dir = tempfile()
+        link = File.join(dir, "link")
+        target = tempfile()
+        Dir.mkdir(dir)
+        File.symlink(target, link)
+        
+        tidy = Puppet::Type.newtidy :path => dir, :size => "1b", :recurse => true
+        assert_apply(tidy)
+        assert(! FileTest.symlink?(link), "link was not tidied")
+    end
+end
+
+# $Id: tidy.rb 2170 2007-02-07 17:21:52Z luke $

data/test/ral/types/user.rb

@@ -0,0 +1,493 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'etc'
+
+class TestUser < Test::Unit::TestCase
+	include PuppetTest
+
+    p = Puppet::Type.type(:user).provide :fake, :parent => PuppetTest::FakeProvider do
+        @name = :fake
+        apimethods
+        def create
+            @ensure = :present
+            @model.eachproperty do |property|
+                next if property.name == :ensure
+                property.sync
+            end
+        end
+
+        def delete
+            @ensure = :absent
+            @model.eachproperty do |property|
+                send(property.name.to_s + "=", :absent)
+            end
+        end
+
+        def exists?
+            if defined? @ensure and @ensure == :present
+                true
+            else
+                false
+            end
+        end
+    end
+
+    FakeUserProvider = p
+
+    @@fakeproviders[:group] = p
+
+    def findshell(old = nil)
+        %w{/bin/sh /bin/bash /sbin/sh /bin/ksh /bin/zsh /bin/csh /bin/tcsh
+            /usr/bin/sh /usr/bin/bash /usr/bin/ksh /usr/bin/zsh /usr/bin/csh
+            /usr/bin/tcsh}.find { |shell|
+                if old
+                    FileTest.exists?(shell) and shell != old
+                else
+                    FileTest.exists?(shell)
+                end
+        }
+    end
+
+    def setup
+        super
+        Puppet::Type.type(:user).defaultprovider = FakeUserProvider
+    end
+
+    def teardown
+        Puppet::Type.type(:user).defaultprovider = nil
+        super
+    end
+
+    def mkuser(name)
+        user = nil
+        assert_nothing_raised {
+            user = Puppet.type(:user).create(
+                :name => name,
+                :comment => "Puppet Testing User",
+                :gid => Puppet::Util::SUIDManager.gid,
+                :shell => findshell(),
+                :home => "/home/%s" % name
+            )
+        }
+
+        assert(user, "Did not create user")
+
+        return user
+    end
+
+    def attrtest_ensure(user)
+        old = user.provider.ensure
+        user[:ensure] = :absent
+
+        comp = newcomp("ensuretest", user)
+        assert_apply(user)
+        assert(!user.provider.exists?, "User is still present")
+        user[:ensure] = :present
+        assert_events([:user_created], comp)
+        assert(user.provider.exists?, "User is absent")
+        user[:ensure] = :absent
+        trans = assert_events([:user_removed], comp)
+
+        assert_rollback_events(trans, [:user_created], "user")
+
+        user[:ensure] = old
+        assert_apply(user)
+    end
+
+    def attrtest_comment(user)
+        user.retrieve
+        old = user.provider.comment
+        user[:comment] = "A different comment"
+
+        comp = newcomp("commenttest", user)
+
+        trans = assert_events([:user_changed], comp, "user")
+
+        assert_equal("A different comment", user.provider.comment,
+            "Comment was not changed")
+
+        assert_rollback_events(trans, [:user_changed], "user")
+
+        assert_equal(old, user.provider.comment,
+            "Comment was not reverted")
+    end
+
+    def attrtest_home(user)
+        obj = nil
+        comp = newcomp("hometest", user)
+
+        old = user.provider.home
+        user[:home] = old
+
+        trans = assert_events([], comp, "user")
+
+        user[:home] = "/tmp"
+
+        trans = assert_events([:user_changed], comp, "user")
+
+        assert_equal("/tmp", user.provider.home, "Home was not changed")
+
+        assert_rollback_events(trans, [:user_changed], "user")
+
+        assert_equal(old, user.provider.home, "Home was not reverted")
+    end
+
+    def attrtest_shell(user)
+        old = user.provider.shell
+        comp = newcomp("shelltest", user)
+
+        user[:shell] = old
+
+        trans = assert_events([], comp, "user")
+
+        newshell = findshell(old)
+
+        unless newshell
+            $stderr.puts "Cannot find alternate shell; skipping shell test"
+            return
+        end
+
+        user[:shell] = newshell
+
+        trans = assert_events([:user_changed], comp, "user")
+
+        user.retrieve
+        assert_equal(newshell, user.provider.shell,
+            "Shell was not changed")
+
+        assert_rollback_events(trans, [:user_changed], "user")
+        user.retrieve
+
+        assert_equal(old, user.provider.shell, "Shell was not reverted")
+    end
+
+    def attrtest_gid(user)
+        obj = nil
+        old = user.provider.gid
+        comp = newcomp("gidtest", user)
+
+        user.retrieve
+
+        user[:gid] = old
+
+        trans = assert_events([], comp, "user")
+
+        newgid = %w{nogroup nobody staff users daemon}.find { |gid|
+                begin
+                    group = Etc.getgrnam(gid)
+                rescue ArgumentError => detail
+                    next
+                end
+                old != group.gid and group.gid > 0
+        }
+
+        unless newgid
+            $stderr.puts "Cannot find alternate group; skipping gid test"
+            return
+        end
+
+        # first test by name
+        assert_nothing_raised("Failed to specify group by name") {
+            user[:gid] = newgid
+        }
+
+        trans = assert_events([:user_changed], comp, "user")
+
+        # then by id
+        newgid = Etc.getgrnam(newgid).gid
+
+        assert_nothing_raised("Failed to specify group by id for %s" % newgid) {
+            user[:gid] = newgid
+        }
+
+        user.retrieve
+
+        assert_events([], comp, "user")
+
+        assert_equal(newgid, user.provider.gid, "GID was not changed")
+
+        assert_rollback_events(trans, [:user_changed], "user")
+
+        assert_equal(old, user.provider.gid, "GID was not reverted")
+    end
+
+    def attrtest_uid(user)
+        obj = nil
+        comp = newcomp("uidtest", user)
+
+        user.provider.uid = 1
+
+        old = 1
+        newuid = 1
+        while true
+            newuid += 1
+
+            if newuid - old > 1000
+                $stderr.puts "Could not find extra test UID"
+                return
+            end
+            begin
+                newuser = Etc.getpwuid(newuid)
+            rescue ArgumentError => detail
+                break
+            end
+        end
+
+        assert_nothing_raised("Failed to change user id") {
+            user[:uid] = newuid
+        }
+
+        trans = assert_events([:user_changed], comp, "user")
+
+        assert_equal(newuid, user.provider.uid, "UID was not changed")
+
+        assert_rollback_events(trans, [:user_changed], "user")
+
+        assert_equal(old, user.provider.uid, "UID was not reverted")
+    end
+
+    def attrtest_groups(user)
+        Etc.setgrent
+        max = 0
+        while group = Etc.getgrent
+            if group.gid > max and group.gid < 5000
+                max = group.gid
+            end
+        end
+
+        groups = []
+        main = []
+        extra = []
+        5.times do |i|
+            i += 1
+            name = "pptstgr%s" % i
+            groups << name
+            if i < 3
+                main << name
+            else
+                extra << name
+            end
+        end
+
+        assert(user[:membership] == :minimum, "Membership did not default correctly")
+
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        # Now add some of them to our user
+        assert_nothing_raised {
+            user[:groups] = extra
+        }
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        assert_instance_of(String, user.property(:groups).should)
+
+        # Some tests to verify that groups work correctly startig from nothing
+        # Remove our user
+        user[:ensure] = :absent
+        assert_apply(user)
+
+        assert_nothing_raised do
+            user.retrieve
+        end
+
+        # And add it again
+        user[:ensure] = :present
+        assert_apply(user)
+
+        # Make sure that the groups are a string, not an array
+        assert(user.provider.groups.is_a?(String),
+            "Incorrectly passed an array to groups")
+
+        user.retrieve
+
+        assert(user.property(:groups).is, "Did not retrieve group list")
+
+        list = user.property(:groups).is
+        assert_equal(extra.sort, list.sort, "Group list is not equal")
+
+        # Now set to our main list of groups
+        assert_nothing_raised {
+            user[:groups] = main
+        }
+
+        assert_equal((main + extra).sort, user.property(:groups).should.split(",").sort)
+
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        assert(!user.insync?, "User is incorrectly in sync")
+
+        assert_apply(user)
+
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        # We're not managing inclusively, so it should keep the old group
+        # memberships and add the new ones
+        list = user.property(:groups).is
+        assert_equal((main + extra).sort, list.sort, "Group list is not equal")
+
+        assert_nothing_raised {
+            user[:membership] = :inclusive
+        }
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        assert(!user.insync?, "User is incorrectly in sync")
+
+        assert_events([:user_changed], user)
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        list = user.property(:groups).is
+        assert_equal(main.sort, list.sort, "Group list is not equal")
+
+        # Set the values a bit differently.
+        user.property(:groups).should = list.sort { |a,b| b <=> a }
+        user.property(:groups).is = list.sort
+
+        assert(user.property(:groups).insync?, "Groups property did not sort groups")
+
+        user.delete(:groups)
+    end
+
+    def test_autorequire
+        file = tempfile()
+        comp = nil
+        user = nil
+        group =nil
+        home = nil
+        ogroup = nil
+        assert_nothing_raised {
+            user = Puppet.type(:user).create(
+                :name => "pptestu",
+                :home => file,
+                :gid => "pptestg",
+                :groups => "yayness"
+            )
+            home = Puppet.type(:file).create(
+                :path => file,
+                :owner => "pptestu",
+                :ensure => "directory"
+            )
+            group = Puppet.type(:group).create(
+                :name => "pptestg"
+            )
+            ogroup = Puppet.type(:group).create(
+                :name => "yayness"
+            )
+            comp = newcomp(user, group, home, ogroup)
+        }
+        
+        rels = nil
+        assert_nothing_raised() { rels = user.autorequire }
+
+        assert(rels.detect { |r| r.source == group }, "User did not require group")
+        assert(rels.detect { |r| r.source == ogroup }, "User did not require other groups")
+        assert_nothing_raised() { rels = home.autorequire }
+        assert(rels.detect { |r| r.source == user }, "Homedir did not require user")
+    end
+
+    def test_simpleuser
+        name = "pptest"
+
+        user = mkuser(name)
+
+        comp = newcomp("usercomp", user)
+
+        trans = assert_events([:user_created], comp, "user")
+
+        assert_equal(user.should(:comment), user.provider.comment,
+            "Comment was not set correctly")
+
+        assert_rollback_events(trans, [:user_removed], "user")
+
+        assert(! user.provider.exists?, "User did not get deleted")
+    end
+
+    def test_allusermodelproperties
+        user = nil
+        name = "pptest"
+
+        user = mkuser(name)
+
+        assert(! user.provider.exists?, "User %s is present" % name)
+
+        comp = newcomp("usercomp", user)
+
+        trans = assert_events([:user_created], comp, "user")
+
+        user.retrieve
+        assert_equal("Puppet Testing User", user.provider.comment,
+            "Comment was not set")
+
+        tests = Puppet.type(:user).validproperties
+
+        tests.each { |test|
+            if self.respond_to?("attrtest_%s" % test)
+                self.send("attrtest_%s" % test, user)
+            else
+                Puppet.err "Not testing attr %s of user" % test
+            end
+        }
+
+        user[:ensure] = :absent
+        assert_apply(user)
+    end
+    
+    # Testing #455
+    def test_autorequire_with_no_group_should
+        user = Puppet::Type.type(:user).create(:name => "yaytest", :check => :all)
+        
+        assert_nothing_raised do
+            user.autorequire
+        end
+
+        user[:ensure] = :absent
+
+        assert_nothing_raised do
+            user.evaluate
+        end
+
+        assert(user.send(:property, :groups).insync?,
+            "Groups state considered out of sync with no :should value")
+    end
+
+    # Make sure the 'managehome' param can only be set when the provider
+    # has that feature.  Uses a patch from #432.
+    def test_managehome
+        user = Puppet::Type.type(:user).create(:name => "yaytest", :check => :all)
+
+        prov = user.provider
+
+        home = false
+        prov.class.meta_def(:manages_homedir?) { home }
+
+        assert_nothing_raised("failed on false managehome") do
+            user[:managehome] = false
+        end
+
+        assert_raise(ArgumentError, "did not fail when managehome? is false") do
+            user[:managehome] = true
+        end
+
+        home = true
+        assert(prov.class.manages_homedir?, "provider did not enable homedir")
+        assert_nothing_raised("failed when managehome is true") do
+            user[:managehome] = true
+        end
+    end
+end
+
+# $Id: user.rb 2328 2007-03-19 21:29:08Z luke $