puppet 0.13.6 → 0.16.0

data/test/types/filebucket.rb

@@ -9,7 +9,7 @@ require 'test/unit'
 require 'fileutils'
 require 'puppettest'
 
-# $Id: filebucket.rb 847 2006-01-23 22:38:39Z luke $
+# $Id: filebucket.rb 1012 2006-03-12 02:56:23Z luke $
 
 class TestFileBucket < Test::Unit::TestCase
 	include FileTesting
@@ -119,12 +119,12 @@ class TestFileBucket < Test::Unit::TestCase
 
         file = mktestfile()
         assert_nothing_raised {
-            file[:backup] = ["filebucket", name]
+            file[:backup] = name
         }
 
         opath = tempfile()
         @@tmpfiles << opath
-        system("cp /etc/passwd %s" % opath)
+        File.open(opath, "w") { |f| f.puts "yaytest" }
 
         origmd5 = File.open(file.name) { |f| newmd5 = Digest::MD5.hexdigest(f.read) }
 
@@ -133,16 +133,7 @@ class TestFileBucket < Test::Unit::TestCase
         #    file[:backup] = true
         #}
 
-        comp = newcomp("yaytest", file)
-
-        trans = nil
-        assert_nothing_raised {
-            trans = comp.evaluate
-        }
-        events = nil
-        assert_nothing_raised {
-            events = trans.evaluate.collect { |e| e.event }
-        }
+        assert_apply(file)
 
         # so, we've now replaced the file with the opath file
         assert_equal(
@@ -159,7 +150,5 @@ class TestFileBucket < Test::Unit::TestCase
             origmd5,
             File.open(file.name) { |f| newmd5 = Digest::MD5.hexdigest(f.read) }
         )
-
-
     end
 end

data/test/types/filesources.rb

@@ -82,16 +82,8 @@ class TestFileSources < Test::Unit::TestCase
                 :source => frompath
             )
         }
-        comp = Puppet.type(:component).create(
-            :name => "component"
-        )
-        comp.push tofile
-        assert_nothing_raised {
-            trans = comp.evaluate
-        }
-        assert_nothing_raised {
-            trans.evaluate
-        }
+
+        assert_apply(tofile)
 
         assert(FileTest.exists?(topath))
         from = File.open(frompath) { |o| o.read }
@@ -333,19 +325,19 @@ class TestFileSources < Test::Unit::TestCase
         list = nil
         rpath = "/root%s" % tmpfile
         assert_nothing_raised {
-            list = client.call("fileserver.list", rpath, false, false)
+            list = client.call("fileserver.list", rpath, :skip, false, false)
         }
 
         assert_equal("/\tfile", list)
 
         assert_nothing_raised {
-            list = client.call("fileserver.describe", rpath)
+            list = client.call("fileserver.describe", rpath, :skip)
         }
 
         assert_match(/^\d+\tfile\t\d+\t\d+\t.+$/, list)
 
         assert_nothing_raised {
-            list = client.call("fileserver.retrieve", rpath)
+            list = client.call("fileserver.retrieve", rpath, :skip)
         }
 
         contents = File.read(tmpfile)
@@ -607,6 +599,43 @@ class TestFileSources < Test::Unit::TestCase
         assert_events([], file)
         assert_events([], file)
     end
+
+    def test_sourcewithlinks
+        source = tempfile()
+        link = tempfile()
+        dest = tempfile()
+
+        File.open(source, "w") { |f| f.puts "yay" }
+        File.symlink(source, link)
+
+        file = nil
+        assert_nothing_raised {
+            file = Puppet.type(:file).create(
+                :name => dest,
+                :source => link
+            )
+        }
+
+        # Default to skipping links
+        assert_events([], file)
+        assert(! FileTest.exists?(dest), "Created link")
+
+        # Now follow the links
+        file[:links] = :follow
+        assert_events([:file_created], file)
+        assert(FileTest.file?(dest), "Destination is not a file")
+
+        # Now copy the links
+        assert_raise(Puppet::FileServerError) {
+            file[:links] = :manage
+            comp = newcomp(file)
+            trans = comp.evaluate
+            trans.evaluate
+        }
+        #assert(FileTest.symlink?(dest), "Destination is not a symlink")
+        #assert_equal(File.readlink(link), File.readlink(dest),
+        #    "Link did not copy correctly")
+    end
 end
 
-# $Id: filesources.rb 884 2006-02-08 17:11:54Z luke $
+# $Id: filesources.rb 984 2006-03-06 18:07:41Z luke $

data/test/types/group.rb

@@ -4,7 +4,7 @@ if __FILE__ == $0
     $puppetbase = "../../../../language/trunk"
 end
 
-# $Id: group.rb 966 2006-03-02 17:12:26Z luke $
+# $Id: group.rb 1113 2006-04-17 16:15:33Z luke $
 
 require 'etc'
 require 'puppet/type'
@@ -234,18 +234,6 @@ 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

data/test/types/mount.rb

@@ -0,0 +1,277 @@
+# Test host job creation, modification, and destruction
+
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppettest'
+require 'puppet'
+require 'puppet/type/parsedtype/mount'
+require 'test/unit'
+require 'facter'
+
+class TestMounts < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        @mounttype = Puppet.type(:mount)
+        @oldfiletype = @mounttype.filetype
+    end
+
+    def teardown
+        @mounttype.filetype = @oldfiletype
+        Puppet.type(:file).clear
+        super
+    end
+
+    # Here we just create a fake host type that answers to all of the methods
+    # but does not modify our actual system.
+    def mkfaketype
+        pfile = tempfile()
+        old = @mounttype.filetype
+        @mounttype.filetype = Puppet::FileType.filetype(:ram)
+
+        cleanup do
+            @mounttype.filetype = old
+            @mounttype.fileobj = nil
+        end
+
+        # Reset this, just in case
+        @mounttype.fileobj = nil
+    end
+
+    def mkmount
+        mount = nil
+
+        if defined? @pcount
+            @pcount += 1
+        else
+            @pcount = 1
+        end
+        args = {
+            :path => "/fspuppet%s" % @pcount,
+            :device => "/dev/dsk%s" % @pcount,
+        }
+
+        Puppet.type(:mount).fields.each do |field|
+            unless args.include? field
+                args[field] = "fake%s" % @pcount
+            end
+        end
+
+        assert_nothing_raised {
+            mount = Puppet.type(:mount).create(args)
+        }
+
+        return mount
+    end
+
+    def test_simplemount
+        mkfaketype
+        host = nil
+        assert_nothing_raised {
+            assert_nil(Puppet.type(:mount).retrieve)
+        }
+
+        mount = mkmount
+
+        assert_nothing_raised {
+            Puppet.type(:mount).store
+        }
+
+        assert_nothing_raised {
+            assert(
+                Puppet.type(:mount).to_file.include?(
+                    Puppet.type(:mount).fileobj.read
+                ),
+                "File does not include all of our objects"
+            )
+        }
+    end
+
+    unless Facter["operatingsystem"].value == "Darwin"
+        def test_mountsparse
+            assert_nothing_raised {
+                @mounttype.retrieve
+            }
+
+            # Now just make we've got some mounts we know will be there
+            root = @mounttype["/"]
+            assert(root, "Could not retrieve root mount")
+        end
+
+        def test_rootfs
+            fs = nil
+            assert_nothing_raised {
+                Puppet.type(:mount).retrieve
+            }
+
+            assert_nothing_raised {
+                fs = Puppet.type(:mount)["/"]
+            }
+            assert(fs, "Could not retrieve root fs")
+
+            assert_nothing_raised {
+                assert(fs.mounted?, "Root is considered not mounted")
+            }
+        end
+    end
+
+    # Make sure it reads and writes correctly.
+    def test_readwrite
+        assert_nothing_raised {
+            Puppet::Type.type(:mount).retrieve
+        }
+
+        oldtype = Puppet::Type.type(:mount).filetype
+
+        # Now switch to storing in ram
+        mkfaketype
+
+        fs = mkmount
+
+        assert(Puppet::Type.type(:mount).filetype != oldtype)
+
+        assert_events([:mount_created], fs)
+
+        text = Puppet::Type.type(:mount).fileobj.read
+
+        assert(text =~ /#{fs[:path]}/, "Text did not include new fs")
+
+        fs[:ensure] = :absent
+
+        assert_events([:mount_removed], fs)
+        text = Puppet::Type.type(:mount).fileobj.read
+
+        assert(text !~ /#{fs[:path]}/, "Text still includes new fs")
+
+        fs[:ensure] = :present
+
+        assert_events([:mount_created], fs)
+
+        text = Puppet::Type.type(:mount).fileobj.read
+
+        assert(text =~ /#{fs[:path]}/, "Text did not include new fs")
+
+        fs[:options] = "rw,noauto"
+
+        assert_events([:mount_changed], fs)
+    end
+
+    if Process.uid == 0
+    def test_mountfs
+        fs = nil
+        case Facter["hostname"].value
+        when "culain": fs = "/ubuntu"
+        when "atalanta": fs = "/mnt"
+        when "figurehead": fs = "/cg4/net/depts"
+        else
+            $stderr.puts "No mount for mount testing; skipping"
+            return
+        end
+
+        assert_nothing_raised {
+            Puppet.type(:mount).retrieve
+        }
+
+        oldtext = Puppet::Type.type(:mount).fileobj.read
+
+        ftype = Puppet::Type.type(:mount).filetype
+
+        # Make sure the original gets reinstalled.
+        if ftype == Puppet::FileType.filetype(:netinfo)
+            cleanup do 
+                IO.popen("niload -r /mounts .", "w") do |file|
+                    file.puts oldtext
+                end
+            end
+        else
+            cleanup do 
+                Puppet::Type.type(:mount).fileobj.write(oldtext)
+            end
+        end
+
+        obj = Puppet.type(:mount)[fs]
+
+        assert(obj, "Could not retrieve %s object" % fs)
+
+        current = nil
+
+        assert_nothing_raised {
+            current = obj.mounted?
+        }
+
+        if current
+            # Make sure the original gets reinstalled.
+            cleanup do
+                unless obj.mounted?
+                    obj.mount
+                end
+            end
+        end
+
+        unless current
+            assert_nothing_raised {
+                obj.mount
+            }
+        end
+
+        # Now copy all of the states' "is" values to the "should" values
+        obj.each do |state|
+            state.should = state.is
+        end
+
+        # Verify we can remove the mount
+        assert_nothing_raised {
+            obj[:ensure] = :absent
+        }
+
+        assert_events([:mount_removed], obj)
+        assert_events([], obj)
+
+        # And verify it's gone
+        assert(!obj.mounted?, "Object is mounted after being removed")
+
+        text = Puppet.type(:mount).fileobj.read
+
+        assert(text !~ /#{fs}/,
+            "Fstab still contains %s" % fs)
+
+        assert_nothing_raised {
+            obj[:ensure] = :present
+        }
+
+        assert_events([:mount_created], obj)
+        assert_events([], obj)
+
+        text = Puppet::Type.type(:mount).fileobj.read
+        assert(text =~ /#{fs}/, "Fstab does not contain %s" % fs)
+
+        assert(! obj.mounted?, "Object is mounted incorrectly")
+
+        assert_nothing_raised {
+            obj[:ensure] = :mounted
+        }
+
+        assert_events([:mount_mounted], obj)
+        assert_events([], obj)
+
+        text = Puppet::Type.type(:mount).fileobj.read
+        assert(text =~ /#{fs}/,
+            "Fstab does not contain %s" % fs)
+
+        obj.retrieve
+        assert(obj.mounted?, "Object is not mounted")
+
+        unless current
+            assert_nothing_raised {
+                obj.unmount
+            }
+        end
+    end
+    end
+end
+
+# $Id: mount.rb 1093 2006-04-06 06:43:43Z luke $

data/test/types/package.rb

@@ -43,7 +43,9 @@ class TestPackages < Test::Unit::TestCase
             pkgs = %w{SMCossh}
         when "Debian": pkgs = %w{ssh openssl}
         when "Fedora": pkgs = %w{openssh}
-        when "OpenBSD": pkgs = %{vim}
+        when "OpenBSD": pkgs = %w{vim}
+        when "FreeBSD": pkgs = %w{sudo}
+        when "Darwin": pkgs = %w{gettext}
         else
             Puppet.notice "No test package for %s" % $platform
             return []
@@ -52,22 +54,29 @@ class TestPackages < Test::Unit::TestCase
         return pkgs
     end
 
-    def mkpkgs
-        tstpkgs().each { |pkg|
-            if pkg.is_a?(Array)
-                hash = {:name => pkg[0], :source => pkg[1]}
-                hash[:ensure] = "present"
-
-                unless File.exists?(hash[:source])
-                    Puppet.info "No package file %s for %s; skipping some package tests" %
-                        [hash[:source], Facter["operatingsystem"].value]
-                end
-                yield Puppet.type(:package).create(hash)
-            else
-                yield Puppet.type(:package).create(
-                    :name => pkg, :ensure => "latest"
-                )
+    def modpkg(pkg)
+        case $platform
+        when "Solaris":
+            pkg[:adminfile] = "/usr/local/pkg/admin_file"
+        end
+    end
+
+    def mkpkgs(list = nil)
+        list ||= tstpkgs()
+        list.each { |pkg, source|
+            hash = {:name => pkg, :ensure => "latest"}
+            if source
+                source = source[0] if source.is_a? Array
+                hash[:source] = source
+            end
+            if Facter["operatingsystem"].value == "Darwin"
+                hash[:type] = "darwinport"
             end
+            obj = Puppet.type(:package).create(hash)
+            assert(pkg, "Could not create package")
+            modpkg(obj)
+
+            yield obj
         }
     end
 
@@ -77,18 +86,32 @@ class TestPackages < Test::Unit::TestCase
         when "Solaris":
             arch = Facter["hardwareisa"].value + Facter["operatingsystemrelease"].value
             case arch
+            when "i3865.10":
+                retval = {"SMCrdesk" => [
+                    "/usr/local/pkg/rdesktop-1.3.1-sol10-intel-local",
+                    "/usr/local/pkg/rdesktop-1.4.1-sol10-x86-local"
+                ]}
             when "sparc5.8":
-                retval = [["SMCarc", "/usr/local/pkg/arc-5.21e-sol8-sparc-local"]]
+                retval = {"SMCarc" => "/usr/local/pkg/arc-5.21e-sol8-sparc-local"}
             when "i3865.8":
-                retval = [["SMCarc", "/usr/local/pkg/arc-5.21e-sol8-intel-local"]]
+                retval = {"SMCarc" => "/usr/local/pkg/arc-5.21e-sol8-intel-local"}
             end
         when "OpenBSD":
-            retval = [["aalib", "ftp://ftp.usa.openbsd.org/pub/OpenBSD/3.8/packages/i386/aalib-1.2-no_x11.tgz"]]
+            retval = {"aalib" => "ftp://ftp.usa.openbsd.org/pub/OpenBSD/3.8/packages/i386/aalib-1.2-no_x11.tgz"}
         when "Debian":
-            retval = %w{zec}
+            retval = {"zec" => nil}
         #when "RedHat": type = :rpm
         when "Fedora":
-            retval = %w{wv}
+            retval = {"wv" => nil}
+        when "CentOS":
+            retval = {"enhost" => [
+                "/home/luke/rpm/RPMS/noarch/enhost-1.0.1-1.noarch.rpm",
+                "/home/luke/rpm/RPMS/noarch/enhost-1.0.2-1.noarch.rpm"
+            ]}
+        when "Darwin":
+            retval = {"aop" => nil}
+        when "FreeBSD":
+            retval = {"yahtzee" => nil}
         else
             Puppet.notice "No test packages for %s" % $platform
         end
@@ -110,13 +133,7 @@ class TestPackages < Test::Unit::TestCase
     end
 
     def test_retrievepkg
-        installedpkgs().each { |pkg|
-            obj = nil
-            assert_nothing_raised {
-                obj = Puppet.type(:package).create(
-                    :name => pkg
-                )
-            }
+        mkpkgs(installedpkgs()) { |obj|
 
             assert(obj, "could not create package")
 
@@ -124,6 +141,7 @@ class TestPackages < Test::Unit::TestCase
                 obj.retrieve
             }
 
+            # Version is a parameter, not a state.
             assert(obj[:version], "Could not retrieve package version")
         }
     end
@@ -136,6 +154,8 @@ class TestPackages < Test::Unit::TestCase
             )
         }
 
+        assert(obj, "Failed to create fake package")
+
         assert_nothing_raised {
             obj.retrieve
         }
@@ -145,22 +165,38 @@ class TestPackages < Test::Unit::TestCase
     end
 
     def test_specifypkgtype
+        pkg = nil
         assert_nothing_raised {
             pkg = Puppet.type(:package).create(
                 :name => "mypkg",
                 :type => "yum"
             )
         }
+        assert(pkg, "Did not create package")
+        assert_equal(:yum, pkg[:type])
     end
 
     def test_latestpkg
-        tstpkgs { |pkg|
+        mkpkgs { |pkg|
+            next unless pkg.respond_to? :latest
             assert_nothing_raised {
                 assert(pkg.latest, "Package did not return value for 'latest'")
             }
         }
     end
 
+    # Make sure our package type supports listing.
+    def test_listing
+        pkgtype = Puppet::Type.type(:package)
+
+        # Heh
+        defaulttype = pkgtype.pkgtype(pkgtype.default)
+
+        assert_nothing_raised("Could not list packages") do
+            defaulttype.list
+        end
+    end
+
     unless Process.uid == 0
         $stderr.puts "Run as root to perform package installation tests"
     else
@@ -181,12 +217,15 @@ class TestPackages < Test::Unit::TestCase
 
             assert_events([:package_created], comp, "package")
 
+            pkg.retrieve
+
+            assert(pkg.insync?, "Package is not in sync")
+
             # then uninstall it
             assert_nothing_raised {
                 pkg[:ensure] = "absent"
             }
 
-
             pkg.retrieve
 
             assert(! pkg.insync?, "Package is in sync")
@@ -194,8 +233,6 @@ class TestPackages < Test::Unit::TestCase
             assert_events([:package_removed], comp, "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.
             if pkg.respond_to?(:latest)
                 assert_nothing_raised {
                     pkg[:ensure] = "latest"
@@ -218,8 +255,102 @@ class TestPackages < Test::Unit::TestCase
             end
         }
     end
+
+    def test_upgradepkg
+        tstpkgs.each do |name, sources|
+            unless sources and sources.is_a? Array
+                $stderr.puts "Skipping pkg upgrade test for %s" % name
+                next
+            end
+            first, second = sources
+
+            unless FileTest.exists?(first) and FileTest.exists?(second)
+                $stderr.puts "Could not find upgrade test pkgs; skipping"
+                return
+            end
+
+            pkg = nil
+            assert_nothing_raised {
+                pkg = Puppet.type(:package).create(
+                    :name => name,
+                    :ensure => :latest,
+                    :source => first
+                )
+            }
+
+            assert(pkg, "Failed to create package %s" % name)
+
+            modpkg(pkg)
+
+            assert(pkg.latest, "Could not retrieve latest value")
+
+            assert_events([:package_created], pkg)
+
+            assert_nothing_raised {
+                pkg.retrieve
+            }
+            assert(pkg.insync?, "Package is not in sync")
+            pkg.clear
+            assert_nothing_raised {
+                pkg[:source] = second
+            }
+            assert_events([:package_changed], pkg)
+
+            assert_nothing_raised {
+                pkg.retrieve
+            }
+            assert(pkg.insync?, "Package is not in sync")
+            assert_nothing_raised {
+                pkg[:ensure] = :absent
+            }
+            assert_events([:package_removed], pkg)
+
+            assert_nothing_raised {
+                pkg.retrieve
+            }
+            assert(pkg.insync?, "Package is not in sync")
+        end
+    end
+
+    # Stupid darwin, not supporting package uninstallation
+    if Facter["operatingsystem"].value == "Darwin" and
+        FileTest.exists? "/Users/luke/Documents/Puppet/pkgtesting.pkg"
+        def test_darwinpkgs
+            pkg = nil
+            assert_nothing_raised {
+                pkg = Puppet::Type.type(:package).create(
+                    :name => "pkgtesting",
+                    :source => "/Users/luke/Documents/Puppet/pkgtesting.pkg",
+                    :ensure => :present
+                )
+            }
+
+            assert_nothing_raised {
+                pkg.retrieve
+            }
+
+            if pkg.insync?
+                Puppet.notice "Test package is already installed; please remove it"
+                next
+            end
+
+            # The file installed, and the receipt
+            @@tmpfiles << "/tmp/file"
+            @@tmpfiles << "/Library/Receipts/pkgtesting.pkg"
+
+            assert_events([:package_created], pkg, "package")
+
+            assert_nothing_raised {
+                pkg.retrieve
+            }
+
+            assert(pkg.insync?, "Package is not insync")
+
+            assert(FileTest.exists?("/tmp/pkgtesting/file"), "File did not get created")
+        end
+    end
     end
 end
 end
 
-# $Id: package.rb 937 2006-02-24 20:00:30Z luke $
+# $Id: package.rb 1128 2006-04-21 03:06:54Z luke $