puppet 0.18.4 → 0.22.4

data/test/{other → util}/metrics.rb

@@ -1,25 +1,15 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet/metric'
 require 'puppet'
+require 'puppet/util/metric'
 require 'puppettest'
 require 'puppet/type'
-require 'test/unit'
-
-$haverrd = true
-begin
-    require 'RRD'
-rescue LoadError
-    $haverrd = false
-end
 
-if $haverrd
+if Puppet.features.rrd?
     class TestMetric < Test::Unit::TestCase
-        include TestPuppet
+        include PuppetTest
 
         def gendata
             totalmax = 1000
@@ -88,4 +78,4 @@ else
     $stderr.puts "Missing RRD library -- skipping metric tests"
 end
 
-# $Id: metrics.rb 1350 2006-06-30 22:30:27Z luke $
+# $Id: metrics.rb 2181 2007-02-08 05:11:49Z luke $

data/test/util/package.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/util/package'
+require 'puppettest'
+
+class TestPuppetUtilPackage < Test::Unit::TestCase
+    include PuppetTest
+    include Puppet::Util::Package
+
+    def test_versioncmp
+        ary = %w{ 1.1.6 2.3 1.1a 3.0 1.5 1 2.4 1.1-4 
+            2.3.1 1.2 2.3.0 1.1-3 2.4b 2.4 2.40.2 2.3a.1 3.1 0002 1.1-5 1.1.a 1.06}
+
+        newary = nil
+        assert_nothing_raised do
+            newary = ary.sort { |a, b|
+                versioncmp(a,b)
+            }
+        end
+        assert_equal(["0002", "1", "1.06", "1.1-3", "1.1-4", "1.1-5", "1.1.6", "1.1.a", "1.1a", "1.2", "1.5", "2.3", "2.3.0", "2.3.1", "2.3a.1", "2.4", "2.4", "2.4b", "2.40.2", "3.0", "3.1"], newary)
+    end
+end
+
+# $Id: package.rb 2132 2007-01-31 06:48:31Z mpalmer $

data/test/util/pidlock.rb

@@ -0,0 +1,126 @@
+require File.dirname(__FILE__) + '/../lib/puppettest'
+
+require 'puppet/util/pidlock'
+require 'fileutils'
+
+# This is *fucked* *up*
+Puppet.debug = false
+
+class TestPuppetUtilPidlock < Test::Unit::TestCase
+	include PuppetTest
+	
+	def setup
+		super
+		@workdir = tstdir
+	end
+	
+	def teardown
+		super
+		FileUtils.rm_rf(@workdir)
+	end
+	
+	def test_00_basic_create
+		l = nil
+		assert_nothing_raised { l = Puppet::Util::Pidlock.new(@workdir + '/nothingmuch') }
+		
+		assert_equal Puppet::Util::Pidlock, l.class
+		
+		assert_equal @workdir + '/nothingmuch', l.lockfile
+	end
+
+	def test_10_uncontended_lock
+		l = Puppet::Util::Pidlock.new(@workdir + '/test_lock')
+		
+		assert !l.locked?
+		assert !l.mine?
+		assert l.lock
+		assert l.locked?
+		assert l.mine?
+		assert !l.anonymous?
+		# It's OK to call lock multiple times
+		assert l.lock
+		assert l.unlock
+		assert !l.locked?
+		assert !l.mine?
+	end
+
+	def test_20_someone_elses_lock
+		childpid = nil
+		l = Puppet::Util::Pidlock.new(@workdir + '/someone_elses_lock')
+		
+		# First, we need a PID that's guaranteed to be (a) used, (b) someone
+		# else's, and (c) around for the life of this test.
+		childpid = fork { loop do; sleep 10; end }
+		
+		File.open(l.lockfile, 'w') { |fd| fd.write(childpid) }
+		
+		assert l.locked?
+		assert !l.mine?
+		assert !l.lock
+		assert l.locked?
+		assert !l.mine?
+		assert !l.unlock
+		assert l.locked?
+		assert !l.mine?
+	ensure
+		Process.kill("KILL", childpid) unless childpid.nil?
+	end
+	
+	def test_30_stale_lock
+		# This is a bit hard to guarantee, but we need a PID that is definitely
+		# unused, and will stay so for the the life of this test.  Our best
+		# bet is to create a process, get it's PID, let it die, and *then*
+		# lock on it.
+		childpid = fork { exit }
+		
+		# Now we can't continue until we're sure that the PID is dead
+		Process.wait(childpid)
+		
+		l = Puppet::Util::Pidlock.new(@workdir + '/stale_lock')
+		
+		# locked? should clear the lockfile
+		File.open(l.lockfile, 'w') { |fd| fd.write(childpid) }
+		assert File.exists?(l.lockfile)
+		assert !l.locked?
+		assert !File.exists?(l.lockfile)
+		
+		# lock should replace the lockfile with our own
+		File.open(l.lockfile, 'w') { |fd| fd.write(childpid) }
+		assert File.exists?(l.lockfile)
+		assert l.lock
+		assert l.locked?
+		assert l.mine?
+		
+		# unlock should fail, and should *not* molest the existing lockfile,
+		# despite it being stale
+		File.open(l.lockfile, 'w') { |fd| fd.write(childpid) }
+		assert File.exists?(l.lockfile)
+		assert !l.unlock
+		assert File.exists?(l.lockfile)
+	end
+
+	def test_40_not_locked_at_all
+		l = Puppet::Util::Pidlock.new(@workdir + '/not_locked')
+		
+		assert !l.locked?
+		# We can't unlock if we don't hold the lock
+		assert !l.unlock
+	end
+	
+	def test_50_anonymous_lock
+		l = Puppet::Util::Pidlock.new(@workdir + '/anonymous_lock')
+		
+		assert !l.locked?
+		assert l.lock(:anonymous => true)
+		assert l.locked?
+		assert l.anonymous?
+		assert !l.mine?
+		assert "", File.read(l.lockfile)
+		assert !l.unlock
+		assert l.locked?
+		assert l.anonymous?
+		assert l.unlock(:anonymous => true)
+		assert !File.exists?(l.lockfile)
+	end
+end
+		

data/test/util/posixtest.rb

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2006-11-07.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/util/posix'
+
+class TestPosixUtil < Test::Unit::TestCase
+	include PuppetTest
+	include Puppet::Util::POSIX
+	
+	def mk_posix_resource(type, obj)
+	    field = idfield(type)
+        res = Puppet::Type.type(type).create(
+            :name => obj.name,
+            field => obj.send(field)
+        )
+        res.setdefaults
+        res
+    end
+	
+	def test_get_posix_field
+	    {:gr => nonrootgroup, :pw => nonrootuser}.each do |space, obj|
+	        if space == :gr
+	            id = :gid
+            else
+                id = :uid
+            end
+	        [obj.name, obj.send(id), obj.send(id).to_s].each do |test|
+        	    value = nil
+        	    assert_nothing_raised do
+        	        value = get_posix_field(space, :name, test)
+        	    end
+        	    assert_equal(obj.name, value)
+    	    end
+	    end
+    end
+    
+    def test_get_provider_value
+        user = nonrootuser
+        obj = mk_posix_resource(:user, user)
+        
+        assert_nothing_raised do
+            assert_equal(user.uid, get_provider_value(:user, :uid, user.uid))
+            assert_equal(user.name, get_provider_value(:user, :name, user.name))
+        end
+    end
+    
+    def test_gid_and_uid
+        {:user => nonrootuser, :group => nonrootgroup}.each do |type, obj|
+            method = idfield(type)
+            # First make sure we get it back with both name and id with no object
+            [obj.name, obj.send(method)].each do |value|
+                assert_equal(obj.send(method), send(method, value))
+            end
+            
+            # Now make a Puppet resource and make sure we get it from that.
+            resource = mk_posix_resource(type, obj)
+            
+            [obj.name, obj.send(method)].each do |value|
+                assert_equal(obj.send(method), send(method, value))
+            end
+        end
+    end
+    
+    def test_util_methods
+        assert(Puppet::Util.respond_to?(:uid), "util does not have methods")
+    end
+    
+    # First verify we can convert a known user
+    def test_gidbyname
+        %x{groups}.split(" ").each { |group|
+            gid = nil
+            assert_nothing_raised {
+                gid = Puppet::Util.gid(group)
+            }
+
+            assert(gid, "Could not retrieve gid for %s" % group)
+        }
+    end
+
+    # Then verify we can retrieve a known group by gid
+    def test_gidbyid
+        %x{groups}.split(" ").each { |group|
+            obj = Puppet.type(:group).create(
+                :name => group,
+                :check => [:gid]
+            )
+            obj.setdefaults
+            obj.retrieve
+            id = obj.is(:gid)
+            gid = nil
+            assert_nothing_raised {
+                gid = Puppet::Util.gid(id)
+            }
+
+            assert(gid, "Could not retrieve gid for %s" % group)
+            assert_equal(id, gid, "Got mismatched ids")
+        }
+    end
+
+    # Finally, verify that we can find groups by id even if we don't
+    # know them
+    def test_gidbyunknownid
+        gid = nil
+        group = Puppet::Util::SUIDManager.gid
+        assert_nothing_raised {
+            gid = Puppet::Util.gid(group)
+        }
+
+        assert(gid, "Could not retrieve gid for %s" % group)
+        assert_equal(group, gid, "Got mismatched ids")
+    end
+
+    def user
+        require 'etc'
+        unless defined? @user
+            obj = Etc.getpwuid(Puppet::Util::SUIDManager.uid)
+            @user = obj.name
+        end
+        return @user
+    end
+
+    # And do it all over again for users
+    # First verify we can convert a known user
+    def test_uidbyname
+        user = user()
+        uid = nil
+        assert_nothing_raised {
+            uid = Puppet::Util.uid(user)
+        }
+
+        assert(uid, "Could not retrieve uid for %s" % user)
+        assert_equal(Puppet::Util::SUIDManager.uid, uid, "UIDs did not match")
+    end
+
+    # Then verify we can retrieve a known user by uid
+    def test_uidbyid
+        user = user()
+        obj = Puppet.type(:user).create(
+            :name => user,
+            :check => [:uid]
+        )
+        obj.setdefaults
+        obj.retrieve
+        id = obj.is(:uid)
+        uid = nil
+        assert_nothing_raised {
+            uid = Puppet::Util.uid(id)
+        }
+
+        assert(uid, "Could not retrieve uid for %s" % user)
+        assert_equal(id, uid, "Got mismatched ids")
+    end
+
+    # Finally, verify that we can find users by id even if we don't
+    # know them
+    def test_uidbyunknownid
+        uid = nil
+        user = Puppet::Util::SUIDManager.uid
+        assert_nothing_raised {
+            uid = Puppet::Util.uid(user)
+        }
+
+        assert(uid, "Could not retrieve uid for %s" % user)
+        assert_equal(user, uid, "Got mismatched ids")
+    end
+end
+
+# $Id: posixtest.rb 2178 2007-02-07 23:56:59Z luke $

data/test/util/storage.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppettest'
+
+class TestStorage < Test::Unit::TestCase
+	include PuppetTest
+
+    def mkfile
+        path = tempfile()
+        File.open(path, "w") { |f| f.puts :yayness }
+
+        f = Puppet.type(:file).create(
+            :name => path,
+            :check => %w{checksum type}
+        )
+
+        return f
+    end
+
+    def test_storeandretrieve
+        path = tempfile()
+
+        f = mkfile()
+
+        # Load first, since that's what we do in the code base; this creates
+        # all of the necessary directories.
+        assert_nothing_raised {
+            Puppet::Util::Storage.load
+        }
+
+        hash = {:a => :b, :c => :d}
+
+        state = nil
+        assert_nothing_raised {
+            state = Puppet::Util::Storage.cache(f)
+        }
+
+        assert(!state.include?("name"))
+
+        assert_nothing_raised {
+            state["name"] = hash
+        }
+
+        assert_nothing_raised {
+            Puppet::Util::Storage.store
+        }
+        assert_nothing_raised {
+            Puppet::Util::Storage.clear
+        }
+        assert_nothing_raised {
+            Puppet::Util::Storage.load
+        }
+
+        # Reset it
+        state = nil
+        assert_nothing_raised {
+            state = Puppet::Util::Storage.cache(f)
+        }
+
+        assert_equal(state["name"], hash)
+    end
+
+    # we're getting corrupt files, probably because multiple processes
+    # are reading or writing the file at once
+    # so we need to test that
+    def test_multiwrite
+        f = mkfile()
+
+        value = {:a => :b}
+        threads = []
+        9.times { |a|
+            threads << Thread.new {
+                9.times { |b|
+                    assert_nothing_raised {
+                        Puppet::Util::Storage.load
+                        state = Puppet::Util::Storage.cache(f)
+                        value.each { |k,v| state[k] = v }
+                        state[:e] = rand(100)
+                        Puppet::Util::Storage.store
+                    }
+                }
+            }
+        }
+        threads.each { |th| th.join }
+    end
+
+    def test_emptyrestore
+        Puppet::Util::Storage.load
+        Puppet::Util::Storage.store
+        Puppet::Util::Storage.clear
+        Puppet::Util::Storage.load
+
+        f = mkfile()
+        state = Puppet::Util::Storage.cache(f)
+        assert_same Hash, state.class
+        assert_equal 0, state.size
+    end
+    
+    def test_caching
+        hash = nil
+        one = Puppet::Type.type(:exec).create :title => "/bin/echo one"
+        [one, :yayness].each do |object|
+            assert_nothing_raised do
+                hash = Puppet::Util::Storage.cache(object)
+            end
+            assert_equal({}, hash, "Did not get empty hash back for %s" % object)
+        
+            hash[:testing] = true
+            assert_nothing_raised do
+                hash = Puppet::Util::Storage.cache(object)
+            end
+            assert_equal({:testing => true}, hash, "Did not get hash back for %s" % object)
+        end
+        assert_raise(ArgumentError, "was able to cache from string") do
+            Puppet::Util::Storage.cache("somethingelse")
+        end
+    end
+end
+
+# $Id: storage.rb 2181 2007-02-08 05:11:49Z luke $