puppet 0.9.2

data/test/types/filetype.rb

@@ -0,0 +1,162 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../../../../language/trunk"
+end
+
+require 'puppet'
+require 'puppet/type/typegen/filetype'
+require 'puppet/type/typegen/filerecord'
+require 'test/unit'
+
+# $Id: filetype.rb 724 2005-10-22 22:27:20Z luke $
+
+#class TestFileType < Test::Unit::TestCase
+class TestFileType
+    def disabled_setup
+        Puppet[:loglevel] = :debug if __FILE__ == $0
+
+        @passwdtype = Puppet::Type::FileType["passwd"]
+        if @passwdtype.nil?
+            assert_nothing_raised() {
+                @passwdtype = Puppet::Type::FileType.createtype(
+                    :name => "passwd"
+                )
+                @passwdtype.addrecord(
+                    :name => "user",
+                    :splitchar => ":",
+                    :fields => %w{name password uid gid gcos home shell}
+                )
+            }
+        end
+
+        @syslogtype = Puppet::Type::FileType["syslog"]
+        if @syslogtype.nil?
+            assert_nothing_raised() {
+                @syslogtype = Puppet::Type::FileType.createtype(
+                    :escapednewlines => true,
+                    :name => "syslog"
+                )
+                @syslogtype.addrecord(
+                    :name => "data",
+                    :regex => %r{^([^#\s]+)\s+(\S+)$},
+                    :joinchar => "\t",
+                    :fields => %w{logs dest}
+                )
+                @syslogtype.addrecord(
+                    :name => "comment",
+                    :regex => %r{^(#.*)$},
+                    :joinchar => "", # not really necessary...
+                    :fields => %w{comment}
+                )
+                @syslogtype.addrecord(
+                    :name => "blank",
+                    :regex => %r{^(\s*)$},
+                    :joinchar => "", # not really necessary...
+                    :fields => %w{blank}
+                )
+            }
+        end
+
+    end
+
+    def disabled_test_passwd1_nochange
+        file = nil
+        type = nil
+        assert_nothing_raised() {
+            file = @passwdtype.new("/etc/passwd")
+        }
+        assert_nothing_raised() {
+            file.retrieve
+        }
+
+        assert(file.insync?)
+
+        contents = ""
+        ::File.open("/etc/passwd") { |ofile|
+            ofile.each { |line|
+                contents += line
+            }
+        }
+
+        assert_equal(
+            contents,
+            file.to_s
+        )
+
+    end
+
+    def disabled_test_passwd2_change
+        file = nil
+        type = nil
+        Kernel.system("cp /etc/passwd /tmp/oparsepasswd")
+        assert_nothing_raised() {
+            file = @passwdtype.new("/tmp/oparsepasswd")
+        }
+        assert_nothing_raised() {
+            file.retrieve
+        }
+
+        assert(file.insync?)
+
+        assert_nothing_raised() {
+            file.add("user") { |obj|
+                obj["name"] = "yaytest"
+                obj["password"] = "x"
+                obj["uid"] = "10000"
+                obj["gid"] = "10000"
+                obj["home"] = "/home/yaytest"
+                obj["gcos"] = "The Yaytest"
+                obj["shell"] = "/bin/sh"
+            }
+        }
+
+        assert(!file.insync?)
+
+        assert_nothing_raised() {
+            file.sync
+        }
+
+        assert(file.insync?)
+
+        assert_nothing_raised() {
+            file.delete("bin")
+        }
+
+        assert(!file.insync?)
+
+        assert_nothing_raised() {
+            file.sync
+        }
+
+        assert(file.insync?)
+
+        Kernel.system("rm /tmp/oparsepasswd")
+    end
+
+    def disabled_test_syslog_nochange
+        file = nil
+        type = nil
+        syslog = File.join($puppetbase, "examples/root/etc/debian-syslog.conf")
+        assert_nothing_raised() {
+            file = @syslogtype.new(syslog)
+        }
+        assert_nothing_raised() {
+            file.retrieve
+        }
+
+        assert(file.insync?)
+
+        contents = ""
+        ::File.open(syslog) { |ofile|
+            ofile.each { |line|
+                contents += line
+            }
+        }
+        #assert_equal(
+        #    contents,
+        #    file.to_s
+        #)
+
+    end
+end

data/test/types/group.rb

@@ -0,0 +1,271 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../../../../language/trunk"
+end
+
+# $Id: group.rb 742 2005-11-16 17:12:11Z luke $
+
+require 'etc'
+require 'puppet/type'
+require 'puppettest'
+require 'test/unit'
+
+class TestGroup < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        @@tmpgroups = []
+    end
+
+    def teardown
+        Puppet::Type::Group.clear
+        @@tmpgroups.each { |group|
+            unless missing?(group)
+                remove(group)
+            end
+        }
+        super
+    end
+
+    case Facter["operatingsystem"].value
+    when "Darwin":
+        def missing?(group)
+            output = %x{nidump -r /groups/#{group} / 2>/dev/null}.chomp
+
+            if output == ""
+                return true
+            else
+                return false
+            end
+
+            assert_equal("", output, "Group %s is present:\n%s" % [group, output])
+        end
+
+        def gid(name)
+            %x{nireport / /groups name gid}.split("\n").each { |line|
+                group, id = line.chomp.split(/\s+/)
+                if group == name
+                    return Integer(id)
+                end
+            }
+
+            return nil
+        end
+
+        def remove(group)
+            system("niutil -destroy / /groups/%s" % group)
+        end
+    else
+        def missing?(group)
+            begin
+                obj = Etc.getgrnam(group)
+                return false
+            rescue ArgumentError
+                return true
+            end
+        end
+
+        def gid(name)
+            assert_nothing_raised {
+                obj = Etc.getgrnam(name)
+                return obj.gid
+            }
+
+            return nil
+        end
+
+        def remove(group)
+            system("groupdel %s" % group)
+        end
+    end
+
+    def groupnames
+        %x{groups}.chomp.split(/ /)
+    end
+
+    def groupids
+        Process.groups
+    end
+
+    def attrtest_gid(group)
+        obj = nil
+        #assert_nothing_raised {
+        #    obj = Etc.getgrnam(group[:name])
+        #}
+        group.retrieve
+        old = gid(group[:name])
+        comp = newcomp("gidtest", group)
+
+        group[:gid] = old
+
+        trans = assert_events(comp, [], "group")
+
+        newgid = old
+        while true
+            newgid += 1
+
+            if newgid - old > 1000
+                $stderr.puts "Could not find extra test UID"
+                return
+            end
+            begin
+                Etc.getgrgid(newgid)
+            rescue ArgumentError => detail
+                break
+            end
+        end
+
+        assert_nothing_raised("Failed to change group id") {
+            group[:gid] = newgid
+        }
+
+        trans = assert_events(comp, [:group_modified], "group")
+
+        curgid = nil
+        assert_nothing_raised {
+            curgid = gid(group[:name])
+        }
+
+        assert_equal(newgid, curgid, "GID was not changed")
+
+        assert_rollback_events(trans, [:group_modified], "group")
+
+        assert_nothing_raised {
+            curgid = gid(group[:name])
+        }
+
+        assert_equal(old, curgid, "UID was not reverted")
+    end
+
+    # Disabled, because it was testing implementation, not function
+    def disabled_test_eachmethod
+        obj = Etc.getgrnam(groupnames()[0])
+
+        assert(obj, "Could not retrieve test group object")
+
+        Puppet::Type::Group.validstates.each { |name, state|
+            assert_nothing_raised {
+                method = state.infomethod
+                assert(method, "State %s has no infomethod" % name)
+                assert(obj.respond_to?(method),
+                    "State %s has an invalid method %s" %
+                    [name, method]
+                )
+            }
+
+            assert_nothing_raised {
+                method = state.infomethod
+                assert(method, "State %s has no infomethod" % name)
+                assert(obj.respond_to?(method),
+                    "State %s has an invalid method %s" %
+                    [name, method]
+                )
+            }
+        }
+    end
+
+    def test_owngroups
+        groupnames().each { |group|
+            gobj = nil
+            comp = nil
+            assert_nothing_raised {
+                gobj = Puppet::Type::Group.create(
+                    :name => group,
+                    :check => [:gid]
+                )
+
+                comp = newcomp("grouptest %s" % group, gobj)
+            }
+
+            trans = nil
+            assert_nothing_raised {
+                trans = comp.evaluate
+            }
+
+            assert(gobj.is(:gid), "Failed to retrieve gid")
+        }
+    end
+
+    # Test that we can query things
+    # It'd be nice if we could automate this...
+    def test_checking
+        require 'etc'
+
+        name = nil
+        assert_nothing_raised {
+            name = Etc.getgrgid(Process.gid).name
+        }
+        user = nil
+        assert_nothing_raised {
+            checks = Puppet::Type::Group.validstates
+            user = Puppet::Type::Group.create(
+                :name => name,
+                :check => checks
+            )
+        }
+
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        assert_equal(Process.gid, user.is(:gid), "Retrieved UID does not match")
+    end
+
+    if Process.uid == 0
+        def test_mkgroup
+            gobj = nil
+            comp = nil
+            name = "pptestgr"
+
+            os = Facter["operatingsystem"].value
+
+            #if os == "Darwin"
+            #    obj = nil
+            #    assert_nothing_raised {
+            #        obj = Etc.getgrnam(name)
+            #    }
+            #    assert_equal(-2, obj.gid, "Darwin GID is not -2")
+            #else
+                #assert_raise(ArgumentError) {
+                #    obj = Etc.getgrnam(name)
+                #}
+            #end
+            assert(missing?(name), "Group %s is still present" % name)
+
+            assert_nothing_raised {
+                gobj = Puppet::Type::Group.create(
+                    :name => name
+                )
+
+                comp = newcomp("groupmaker %s" % name, gobj)
+            }
+
+            @@tmpgroups << name
+            trans = assert_events(comp, [:group_created], "group")
+
+            obj = nil
+            assert_nothing_raised {
+                obj = Etc.getgrnam(name)
+            }
+            assert(!missing?(name), "Group %s is missing" % name)
+
+            tests = Puppet::Type::Group.validstates
+
+            gobj.retrieve
+            tests.each { |test|
+                if self.respond_to?("attrtest_%s" % test)
+                    self.send("attrtest_%s" % test, gobj)
+                else
+                    #$stderr.puts "Not testing attr %s of group" % test
+                end
+            }
+
+            assert_rollback_events(trans, [:group_deleted], "group")
+
+            assert(missing?(name), "Group %s is still present" % name)
+        end
+    else
+        $stderr.puts "Not running as root; skipping group creation tests."
+    end
+end

data/test/types/package.rb

@@ -0,0 +1,205 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppettest'
+require 'puppet'
+require 'test/unit'
+require 'facter'
+
+$platform = Facter["operatingsystem"].value
+
+unless Puppet::Type::Package.default
+    puts "No default package type for %s; skipping package tests" % $platform
+else
+
+class TestPackageSource < Test::Unit::TestCase
+	include TestPuppet
+    def test_filesource
+        system("touch /tmp/fakepackage")
+        assert_equal(
+            "/tmp/fakepackage",
+            Puppet::PackageSource.get("file:///tmp/fakepackage")
+        )
+        system("rm -f /tmp/fakepackage")
+    end
+end
+
+class TestPackages < Test::Unit::TestCase
+	include FileTesting
+    def setup
+        super
+        #@list = Puppet::Type::Package.getpkglist
+        Puppet::Type::Package.clear
+    end
+
+    # These are packages that we're sure will be installed
+    def installedpkgs
+        pkgs = nil
+        case $platform
+        when "SunOS"
+            pkgs = %w{SMCossh}
+        when "Linux"
+            case Facter["distro"].value
+            when "Debian": pkgs = %w{ssh openssl}
+            when "Fedora": pkgs = %w{openssh}
+            #when "RedHat": type = :rpm
+            else
+                Puppet.notice "No test package for %s" % $platform 
+                return []
+            end
+        else
+            Puppet.notice "No test package for %s" % $platform
+            return []
+        end
+
+        return pkgs
+    end
+
+    def tstpkg
+        case $platform
+        #when "SunOS"
+        #    type = "sunpkg"
+        when "Linux"
+            case Facter["distro"].value
+            when "Debian":
+                return %w{zec}
+            #when "RedHat": type = :rpm
+            when "Fedora":
+                return %w{wv}
+            else
+                Puppet.notice "No test packags for %s" % $platform
+                return nil
+            end
+        else
+            Puppet.notice "No test packags for %s" % $platform
+            return nil
+        end
+    end
+
+    def mkpkgcomp(pkg)
+        assert_nothing_raised {
+            pkg = Puppet::Type::Package.create(:name => pkg, :install => true)
+        }
+        assert_nothing_raised {
+            pkg.retrieve
+        }
+
+        comp = newcomp("package", pkg)
+
+        return comp
+    end
+
+    def test_retrievepkg
+        installedpkgs().each { |pkg|
+            obj = nil
+            assert_nothing_raised {
+                obj = Puppet::Type::Package.create(
+                    :name => pkg
+                )
+            }
+
+            assert(obj, "could not create package")
+
+            assert_nothing_raised {
+                obj.retrieve
+            }
+
+            assert(obj.is(:install), "Could not retrieve package version")
+        }
+    end
+
+    def test_nosuchpkg
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet::Type::Package.create(
+                :name => "thispackagedoesnotexist"
+            )
+        }
+
+        assert_nothing_raised {
+            obj.retrieve
+        }
+
+        assert_equal(:notinstalled, obj.is(:install),
+            "Somehow retrieved unknown pkg's version")
+    end
+
+    def test_latestpkg
+        pkgs = tstpkg || return
+
+        pkgs.each { |name|
+            pkg = Puppet::Type::Package.create(:name => name)
+            assert_nothing_raised {
+                assert(pkg.latest, "Package did not return value for 'latest'")
+            }
+        }
+    end
+
+    unless Process.uid == 0
+        $stderr.puts "Run as root to perform package installation tests"
+    else
+    def test_installpkg
+        pkgs = tstpkg || return
+        pkgs.each { |pkg|
+            # we first set install to 'true', and make sure something gets
+            # installed
+            assert_nothing_raised {
+                pkg = Puppet::Type::Package.create(:name => pkg, :install => true)
+            }
+            assert_nothing_raised {
+                pkg.retrieve
+            }
+
+            if pkg.insync?
+                Puppet.notice "Test package %s is already installed; please choose a different package for testing" % pkg
+                next
+            end
+
+            comp = newcomp("package", pkg)
+
+            assert_events(comp, [:package_installed], "package")
+
+            # then uninstall it
+            assert_nothing_raised {
+                pkg[:install] = false
+            }
+
+
+            pkg.retrieve
+
+            assert(! pkg.insync?, "Package is insync")
+
+            assert_events(comp, [:package_removed], "package")
+
+            # and now set install to 'latest' and verify it installs
+            # FIXME this isn't really a very good test -- we should install
+            # a low version, and then upgrade using this.  But, eh.
+            assert_nothing_raised {
+                pkg[:install] = "latest"
+            }
+
+            assert_events(comp, [:package_installed], "package")
+
+            pkg.retrieve
+            assert(pkg.insync?, "After install, package is not insync")
+
+            assert_nothing_raised {
+                pkg[:install] = false
+            }
+
+
+            pkg.retrieve
+
+            assert(! pkg.insync?, "Package is insync")
+
+            assert_events(comp, [:package_removed], "package")
+        }
+    end
+    end
+end
+end
+
+# $Id: package.rb 742 2005-11-16 17:12:11Z luke $