puppet 0.16.0 → 0.18.4

data/test/types/group.rb

@@ -4,7 +4,7 @@ if __FILE__ == $0
     $puppetbase = "../../../../language/trunk"
 end
 
-# $Id: group.rb 1113 2006-04-17 16:15:33Z luke $
+# $Id: group.rb 1416 2006-07-21 19:05:30Z luke $
 
 require 'etc'
 require 'puppet/type'
@@ -28,6 +28,16 @@ class TestGroup < Test::Unit::TestCase
         super
     end
 
+    def mkgroup(name, hash = {})
+        group = nil
+        hash[:name] = name
+        assert_nothing_raised {
+            group = Puppet.type(:group).create(hash)
+        }
+
+        return group
+    end
+
     case Facter["operatingsystem"].value
     when "Darwin":
         def missing?(group)
@@ -287,6 +297,26 @@ class TestGroup < Test::Unit::TestCase
 
             assert(missing?(name), "Group %s is still present" % name)
         end
+
+        # groupadd -o is broken in FreeBSD.
+        unless Facter["operatingsystem"].value == "FreeBSD"
+        def test_duplicateIDs
+            group1 = mkgroup("group1", :gid => 125)
+            group2 = mkgroup("group2", :gid => 125)
+
+            assert_apply(group1)
+
+            # 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 {
+                group2[:allowdupe] = true
+            }
+            assert_apply(group2)
+            group2.retrieve
+            assert_equal(:present, group2.state(:ensure).is,
+                         "Group did not get created")
+        end
+        end
     else
         $stderr.puts "Not running as root; skipping group creation tests."
     end

data/test/types/host.rb

@@ -21,6 +21,7 @@ class TestHost < Test::Unit::TestCase
     end
 
     def teardown
+        Puppet::FileType.filetype(:ram).clear
         @hosttype.filetype = @oldhosttype
         Puppet.type(:file).clear
         super
@@ -182,4 +183,4 @@ class TestHost < Test::Unit::TestCase
     end
 end
 
-# $Id: host.rb 910 2006-02-15 07:20:36Z luke $
+# $Id: host.rb 1421 2006-07-21 23:12:51Z luke $

data/test/types/mount.rb

@@ -93,6 +93,7 @@ class TestMounts < Test::Unit::TestCase
 
     unless Facter["operatingsystem"].value == "Darwin"
         def test_mountsparse
+            use_fake_fstab
             assert_nothing_raised {
                 @mounttype.retrieve
             }
@@ -104,6 +105,7 @@ class TestMounts < Test::Unit::TestCase
 
         def test_rootfs
             fs = nil
+            use_fake_fstab
             assert_nothing_raised {
                 Puppet.type(:mount).retrieve
             }
@@ -121,6 +123,7 @@ class TestMounts < Test::Unit::TestCase
 
     # Make sure it reads and writes correctly.
     def test_readwrite
+        use_fake_fstab
         assert_nothing_raised {
             Puppet::Type.type(:mount).retrieve
         }
@@ -272,6 +275,20 @@ class TestMounts < Test::Unit::TestCase
         end
     end
     end
+
+    def use_fake_fstab
+        os = Facter['operatingsystem']
+        if os == "Solaris"
+            name = "solaris.fstab"
+        elsif os == "FreeBSD"
+            name = "freebsd.fstab"
+        else
+            # Catchall for other fstabs
+            name = "linux.fstab"
+        end
+        fstab = fakefile(File::join("data/types/mount", name))
+        Puppet::Type.type(:mount).path = fstab
+    end
 end
 
-# $Id: mount.rb 1093 2006-04-06 06:43:43Z luke $
+# $Id: mount.rb 1343 2006-06-30 01:43:02Z lutter $

data/test/types/package.rb

@@ -15,18 +15,6 @@ 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
-        path = tempfile()
-        system("touch %s" % path)
-        assert_equal(
-            path,
-            Puppet::PackageSource.get("file://#{path}")
-        )
-    end
-end
-
 class TestPackages < Test::Unit::TestCase
 	include FileTesting
     def setup
@@ -61,10 +49,13 @@ class TestPackages < Test::Unit::TestCase
         end
     end
 
-    def mkpkgs(list = nil)
+    def mkpkgs(list = nil, useensure = true)
         list ||= tstpkgs()
         list.each { |pkg, source|
-            hash = {:name => pkg, :ensure => "latest"}
+            hash = {:name => pkg}
+            if useensure
+                hash[:ensure] = "latest"
+            end
             if source
                 source = source[0] if source.is_a? Array
                 hash[:source] = source
@@ -150,7 +141,8 @@ class TestPackages < Test::Unit::TestCase
         obj = nil
         assert_nothing_raised {
             obj = Puppet.type(:package).create(
-                :name => "thispackagedoesnotexist"
+                :name => "thispackagedoesnotexist",
+                :ensure => :installed
             )
         }
 
@@ -162,6 +154,18 @@ class TestPackages < Test::Unit::TestCase
 
         assert_equal(:absent, obj.is(:ensure),
             "Somehow retrieved unknown pkg's version")
+
+        state = obj.state(:ensure)
+        assert(state, "Could not retrieve ensure state")
+
+        # Add a fake state, for those that need it
+        file = tempfile()
+        File.open(file, "w") { |f| f.puts :yayness }
+        obj[:source] = file
+        assert_raise(Puppet::PackageError,
+            "Successfully installed nonexistent package") {
+            state.sync
+        }
     end
 
     def test_specifypkgtype
@@ -180,7 +184,8 @@ class TestPackages < Test::Unit::TestCase
         mkpkgs { |pkg|
             next unless pkg.respond_to? :latest
             assert_nothing_raised {
-                assert(pkg.latest, "Package did not return value for 'latest'")
+                assert(pkg.latest,
+                    "Package %s did not return value for 'latest'" % pkg.name)
             }
         }
     end
@@ -208,7 +213,7 @@ class TestPackages < Test::Unit::TestCase
                 pkg.retrieve
             }
 
-            if pkg.insync?
+            if pkg.insync? or pkg.is(:ensure) != :absent
                 Puppet.notice "Test package %s is already installed; please choose a different package for testing" % pkg
                 next
             end
@@ -256,6 +261,25 @@ class TestPackages < Test::Unit::TestCase
         }
     end
 
+    # Make sure that a default is used for 'ensure'
+    def test_ensuredefault
+        # Tell mkpkgs not to set 'ensure'.
+        mkpkgs(nil, false) { |pkg|
+            assert_nothing_raised {
+                pkg.retrieve
+            }
+
+            assert(!pkg.insync?, "Package thinks it's in sync")
+
+            assert_apply(pkg)
+            pkg.retrieve
+            assert(pkg.insync?, "Package does not think it's in sync")
+
+            pkg[:ensure] = :absent
+            assert_apply(pkg)
+        }
+    end
+
     def test_upgradepkg
         tstpkgs.each do |name, sources|
             unless sources and sources.is_a? Array
@@ -349,8 +373,166 @@ class TestPackages < Test::Unit::TestCase
             assert(FileTest.exists?("/tmp/pkgtesting/file"), "File did not get created")
         end
     end
+
+    # Yay, gems.  They're special because any OS can test them.
+    if %x{which gem 2>/dev/null}.chomp != ""
+    def test_list_gems
+        gems = nil
+        assert_nothing_raised {
+            gems = Puppet::Type.type(:package).pkgtype(:gem).list
+        }
+
+        gems.each do |gem|
+            assert_equal(:gem, gem[:type],
+                "Type was not set correctly")
+        end
+    end
+
+    def test_install_gems
+        gem = nil
+        name = "wxrubylayouts"
+        assert_nothing_raised {
+            gem = Puppet::Type.newpackage(
+                :name => name,
+                :version => "0.0.2",
+                :ensure => "installed",
+                :type => :gem
+            )
+        }
+
+        assert_nothing_raised {
+            gem.retrieve
+        }
+
+        if gem.is(:ensure) != :absent
+            $stderr.puts "Cannot test gem installation; %s is already installed" %
+                name
+            return
+        end
+
+        assert_events([:package_created], gem)
+
+        assert_nothing_raised {
+            gem.retrieve
+        }
+
+        assert_equal("0.0.2", gem.is(:ensure),
+            "Incorrect version was installed")
+
+        latest = nil
+        assert_nothing_raised {
+            latest = gem.latest
+        }
+
+        assert(latest != gem[:version], "Did not correctly find latest value")
+
+        gem[:ensure] = :latest
+        assert_events([:package_changed], gem)
+
+        gem.retrieve
+
+        assert("0.0.2" != gem.is(:ensure),
+            "Package was not updated.")
+
+        gem[:ensure] = :absent
+
+        assert_events([:package_removed], gem)
+    end
+
+    else
+    def test_nogems_nofailures
+        obj = nil
+        assert_nothing_raised do
+            Puppet::Type.newpackage(
+                :name => "yayness",
+                :type => "gem",
+                :ensure => "installed"
+            )
+        end
+
+        assert_nil(Puppet::Type.type(:package)["yayness"],
+            "Invalid gem package got created")
+    end
+    end
+    end
+    if ["Fedora", "RedHat", "CentOS"].include?(Facter["operatingsystem"].value) and
+        FileTest.exists?("/home/luke/rpm/RPMS/i386/puppet-server-0.16.1-1.i386.rpm")
+
+    # We have a special test here, because we don't actually want to install the
+    # package, just make sure it's getting the "latest" value.
+    def test_rpmlatest
+        pkg = nil
+        assert_nothing_raised {
+            pkg = Puppet::Type.type(:package).create(
+                :type => :rpm,
+                :name => "puppet-server",
+                :source => "/home/luke/rpm/RPMS/i386/puppet-server-0.16.1-1.i386.rpm"
+            )
+        }
+
+        assert_equal("0.16.1-1", pkg.latest, "RPM did not provide correct value for latest")
+    end
+    end
+
+    if Facter["operatingsystem"].value == "Solaris"
+    if pkgget = %x{which pkg-get 2>/dev/null}.chomp and pkgget != ""
+    # FIXME The packaging crap needs to be rewritten to support testing
+    # multiple package types on the same platform.
+    def test_list_blastwave
+        pkgs = nil
+        assert_nothing_raised {
+            pkgs = Puppet::Type.type(:package).pkgtype(:blastwave).list
+        }
+
+        pkgs.each do |pkg|
+            if pkg[:name] =~ /^CSW/
+                assert_equal(:blastwave, pkg[:type],
+                    "Type was not set correctly")
+            end
+        end
+    end
+
+    def test_install_blastwave
+        pkg = nil
+        name = "cabextract"
+        assert_nothing_raised {
+            pkg = Puppet::Type.newpackage(
+                :name => name,
+                :ensure => "installed",
+                :type => :blastwave
+            )
+        }
+
+        assert_nothing_raised {
+            pkg.retrieve
+        }
+
+        if pkg.is(:ensure) != :absent
+            p pkg.is(:ensure)
+            $stderr.puts "Cannot test pkg installation; %s is already installed" %
+                name
+            return
+        end
+
+        assert_events([:package_created], pkg)
+
+        assert_nothing_raised {
+            pkg.retrieve
+        }
+
+        latest = nil
+        assert_nothing_raised {
+            latest = pkg.latest
+        }
+        pkg[:ensure] = :absent
+
+        assert_events([:package_removed], pkg)
+    end
+    else
+        $stderr.puts "No pkg-get scripting; skipping blastwave tests"
+    end
     end
 end
 end
 
-# $Id: package.rb 1128 2006-04-21 03:06:54Z luke $
+# $Id: package.rb 1356 2006-07-04 05:45:28Z luke $

data/test/types/service.rb

@@ -37,6 +37,8 @@ class TestInitService
         case Facter["operatingsystem"].value.downcase
         when "solaris":
             return ["smtp", "xf"]
+        when "redhat":
+            return ["sshd"]
         end
     end
 
@@ -134,6 +136,8 @@ class TestLocalService < Test::Unit::TestCase
             return {"hddtemp" => {}}
         when "centos":
             return {"cups" => {:hasstatus => true}}
+        when "redhat":
+            return {"saslauthd" => {:hasstatus => true}}
         end
 
         Puppet.notice "No test services for %s-%s" %
@@ -303,4 +307,4 @@ class TestLocalService < Test::Unit::TestCase
 end
 end
 
-# $Id: service.rb 1033 2006-03-14 20:00:20Z luke $
+# $Id: service.rb 1265 2006-06-13 22:55:14Z luke $

data/test/types/sshkey.rb

@@ -22,6 +22,7 @@ class TestSSHKey < Test::Unit::TestCase
     end
 
     def teardown
+        Puppet::FileType.filetype(:ram).clear
         @sshtype.filetype = @oldfiletype
         Puppet.type(:file).clear
         super
@@ -178,4 +179,4 @@ class TestSSHKey < Test::Unit::TestCase
     end
 end
 
-# $Id: sshkey.rb 910 2006-02-15 07:20:36Z luke $
+# $Id: sshkey.rb 1421 2006-07-21 23:12:51Z luke $

data/test/types/symlink.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: symlink.rb 1015 2006-03-12 03:19:53Z luke $
+# $Id: symlink.rb 1256 2006-06-13 15:57:06Z luke $
 
 class TestSymlink < Test::Unit::TestCase
 	include FileTesting
@@ -41,6 +41,7 @@ class TestSymlink < Test::Unit::TestCase
         unless hash.include?(:ensure)
             hash[:ensure] = mktmpfile()
         end
+
         link = Puppet.type(:symlink).create(hash)
         return link
     end
@@ -73,7 +74,7 @@ class TestSymlink < Test::Unit::TestCase
         assert_nothing_raised {
             link = newlink(:ensure => source, :recurse => true)
         }
-        comp = newcomp("linktest",link)
+        comp = newcomp(link)
         cycle(comp)
 
         path = link.name