puppet 0.18.4 → 0.22.4

data/test/puppet/conffiles.rb

@@ -1,16 +1,12 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = ".."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet'
-require 'puppet/config'
 require 'puppettest'
-require 'test/unit'
+require 'puppet/util/config'
 
 class TestConfFiles < Test::Unit::TestCase
-    include TestPuppet
+    include PuppetTest
 
     @@gooddata = [
         {
@@ -76,7 +72,7 @@ class TestConfFiles < Test::Unit::TestCase
         path = tempfile()
 
         sampledata { |data|
-            config = Puppet::Config.new
+            config = Puppet::Util::Config.new
             data.each { |section, hash|
                 hash.each { |param, value|
                     config.setdefaults(section, param => [value, value])
@@ -99,6 +95,15 @@ class TestConfFiles < Test::Unit::TestCase
             }
         }
     end
+
+    # Make sure that basic config generation works; this also ensures
+    # that the default config is free of simple typos etc.
+    def test_genconfig
+        assert_nothing_raised {
+            Puppet::config::to_config
+        }
+    end
+
 end
 
-# $Id: conffiles.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: conffiles.rb 2261 2007-03-07 22:20:51Z lutter $

data/test/puppet/defaults.rb

@@ -1,24 +1,21 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = ".."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppettest'
-require 'test/unit'
 
-# $Id: defaults.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: defaults.rb 2178 2007-02-07 23:56:59Z luke $
 
 class TestPuppetDefaults < Test::Unit::TestCase
-    include TestPuppet
+    include PuppetTest
     @@dirs = %w{rrddir confdir vardir logdir statedir}
     @@files = %w{statefile manifest masterlog}
     @@normals = %w{puppetport masterport server}
     @@booleans = %w{rrdgraph noop}
 
     def testVersion
-        assert( Puppet.version =~ /^[0-9]+(\.[0-9]+)*$/ )
+        assert( Puppet.version =~ /^[0-9]+(\.[0-9]+)*/, "got invalid version number %s" % Puppet.version )
     end
 
     def testStringOrParam
@@ -70,7 +67,7 @@ class TestPuppetDefaults < Test::Unit::TestCase
     # we don't want user defaults in /, or root defaults in ~
     def testDefaultsInCorrectRoots
         notval = nil
-        if Process.uid == 0
+        if Puppet::Util::SUIDManager.uid == 0
             notval = Regexp.new(File.expand_path("~"))
         else
             notval = /^\/var|^\/etc/

data/test/puppet/{error.rb → errortest.rb}

@@ -1,15 +1,12 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppettest'
-require 'test/unit'
 
 class TestError < Test::Unit::TestCase
-    include TestPuppet
+    include PuppetTest
 
     def test_errorisstring
         error = nil
@@ -20,4 +17,4 @@ class TestError < Test::Unit::TestCase
     end
 end
 
-# $Id: error.rb 740 2005-11-01 20:22:19Z luke $
+# $Id: errortest.rb 1793 2006-10-16 22:01:40Z luke $

data/test/puppet/modules.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppettest'
+
+class TestModules < Test::Unit::TestCase
+	include PuppetTest
+
+    def setup
+        super
+        @varmods = File::join(Puppet[:vardir], "modules")
+        FileUtils::mkdir_p(@varmods)
+    end
+
+    def test_modulepath
+        Puppet[:modulepath] = "$vardir/modules:/no/such/path/anywhere:.::"
+        assert_equal([ @varmods ], Puppet::Module.modulepath)
+    end
+
+    def test_find
+        assert_nil(Puppet::Module::find("/tmp"))
+
+        file = "testmod/something"
+        assert_nil(Puppet::Module::find(file))
+
+        path = File::join(@varmods, "testmod")
+        FileUtils::mkdir_p(path)
+
+        mod = Puppet::Module::find("testmod")
+        assert_not_nil(mod)
+        assert_equal("testmod", mod.name)
+        assert_equal(path, mod.path)
+
+        mod = Puppet::Module::find(file)
+        assert_not_nil(mod)
+        assert_equal("testmod", mod.name)
+        assert_equal(path, mod.path)
+    end
+
+    def test_find_template
+        templ = "testmod/templ.erb"
+        assert_equal(File::join(Puppet[:templatedir], templ),
+                     Puppet::Module::find_template(templ))
+
+        templ_path = File::join(@varmods, "testmod",
+                                Puppet::Module::TEMPLATES, "templ.erb")
+        FileUtils::mkdir_p(File::dirname(templ_path))
+        File::open(templ_path, "w") { |f| f.puts "Howdy" }
+
+        assert_equal(templ_path, Puppet::Module::find_template(templ))
+
+        mod = Puppet::Module::find(templ)
+        assert_not_nil(mod)
+        assert_equal(templ_path, mod.template(templ))
+    end
+end

data/test/puppet/tc_suidmanager.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestSUIDManager < Test::Unit::TestCase
+    include PuppetTest
+
+    def setup
+        if Process.uid != 0
+            warn "Process tests must be run as root"
+            @run = false
+        else 
+            @run = true
+        end
+        super
+    end
+
+    def test_metaprogramming_function_additions
+        # NOTE: the way that we are dynamically generating the methods in
+        # SUIDManager for the UID/GID calls was causing problems due to the
+        # modification of a closure. Should the bug rear itself again, this
+        # test will fail.
+        assert_nothing_raised do
+            Puppet::Util::SUIDManager.uid
+            Puppet::Util::SUIDManager.uid
+        end
+    end
+
+    def test_id_set
+        if @run
+            user = nonrootuser
+            assert_nothing_raised do
+                Puppet::Util::SUIDManager.egid = user.gid
+                Puppet::Util::SUIDManager.euid = user.uid
+            end
+            
+            assert_equal(Puppet::Util::SUIDManager.euid, Process.euid)
+            assert_equal(Puppet::Util::SUIDManager.egid, Process.egid)
+
+            assert_nothing_raised do
+                Puppet::Util::SUIDManager.euid = 0
+                Puppet::Util::SUIDManager.egid = 0
+            end
+        end
+    end
+
+    def test_utiluid
+        user = nonrootuser.name
+        if @run
+            assert_not_equal(nil, Puppet::Util.uid(user))
+        end
+    end
+
+    def test_asuser
+        if @run
+            user = nonrootuser
+            uid, gid = [nil, nil]
+
+            assert_nothing_raised do
+                Puppet::Util::SUIDManager.asuser(user.uid, user.gid) do 
+                    uid = Process.euid
+                    gid = Process.egid
+                end
+            end
+            assert_equal(user.uid, uid)
+            assert_equal(user.gid, gid)
+        end
+    end
+
+    def test_system
+        # NOTE: not sure what shells this will work on..
+        if @run 
+            user = nonrootuser
+            status = Puppet::Util::SUIDManager.system("exit $EUID", user.uid, user.gid)
+            assert_equal(user.uid, status.exitstatus)
+        end
+    end
+
+    def test_run_and_capture
+        if (RUBY_VERSION <=> "1.8.4") < 0
+            warn "Cannot run this test on ruby < 1.8.4"
+        else
+            # NOTE: because of the way that run_and_capture currently 
+            # works, we cannot just blindly echo to stderr. This little
+            # hack gets around our problem, but the real problem is the
+            # way that run_and_capture works.
+            user = nil
+            uid = nil
+            if Puppet::Util::SUIDManager.uid == 0
+                userobj = nonrootuser()
+                user = userobj.name
+                uid = userobj.uid
+            else
+                uid = Process.uid
+            end
+            cmd = [%{/bin/echo $EUID}]
+            output = Puppet::Util::SUIDManager.run_and_capture(cmd, uid)[0].chomp
+            assert_equal(uid.to_s, output)
+        end
+    end
+end
+
+# $Id: tc_suidmanager.rb 2178 2007-02-07 23:56:59Z luke $

data/test/rails/host.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/rails'
+require 'puppet/parser/interpreter'
+require 'puppet/parser/parser'
+require 'puppet/network/client'
+require 'puppettest'
+require 'puppettest/parsertesting'
+require 'puppettest/resourcetesting'
+require 'puppettest/railstesting'
+
+class TestRailsHost < Test::Unit::TestCase
+    include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+    include PuppetTest::RailsTesting
+
+    def setup
+        super
+        railsinit if Puppet.features.rails?
+    end
+
+    def teardown
+        railsteardown if Puppet.features.rails?
+        super
+    end
+
+    def test_includerails
+        assert_nothing_raised {
+            require 'puppet/rails'
+        }
+    end
+
+    # Don't do any tests w/out this class
+    if Puppet.features.rails?
+    def test_store
+        @interp, @scope, @source = mkclassframing
+        # First make some objects
+        resources = []
+        4.times { |i|
+            # Make a file
+            resources << mkresource(:type => "file",
+                :title => "/tmp/file#{i.to_s}",
+                :params => {:owner => "user#{i}"})
+
+            # And an exec, so we're checking multiple types
+            resources << mkresource(:type => "exec",
+                :title => "/bin/echo file#{i.to_s}",
+                :params => {:user => "user#{i}"})
+        }
+
+        # Now collect our facts
+        facts = {"hostname" => Facter.value(:hostname), "test1" => "funtest",
+            "ipaddress" => Facter.value(:ipaddress)}
+
+        # Now try storing our crap
+        host = nil
+        assert_nothing_raised {
+            host = Puppet::Rails::Host.store(
+                :resources => resources,
+                :facts => facts,
+                :name => facts["hostname"],
+                :classes => ["one", "two::three", "four"]
+            )
+        }
+
+        assert(host, "Did not create host")
+
+        host = nil
+        assert_nothing_raised {
+            host = Puppet::Rails::Host.find_by_name(facts["hostname"])
+        }
+        assert(host, "Could not find host object")
+
+        assert(host.resources, "No objects on host")
+
+        facts.each do |fact, value|
+            assert_equal(value, host.fact(fact), "fact %s is wrong" % fact)
+        end
+        assert_equal(facts["ipaddress"], host.ip, "IP did not get set")
+
+        count = 0
+        host.resources.each do |resource|
+            assert_equal(host, resource.host)
+            count += 1
+            i = nil
+            if resource[:title] =~ /file([0-9]+)/
+                i = $1
+            else
+                raise "Got weird resource %s" % resource.inspect
+            end
+            assert(resource[:restype] != "", "Did not get a type from the resource")
+            case resource["restype"]
+            when "file":
+                assert_equal("user#{i}", resource.parameter("owner"),
+                    "got no owner for %s" % resource.ref)
+            when "exec":
+                assert_equal("user#{i}", resource.parameter("user"),
+                    "got no user for %s" % resource.ref)
+            else
+                raise "Unknown type %s" % resource[:restype].inspect
+            end
+        end
+
+        assert_equal(8, count, "Did not get enough resources")
+
+        # Now remove a couple of resources
+        resources.reject! { |r| r.title =~ /file3/ }
+
+        # Change a few resources
+        resources.find_all { |r| r.title =~ /file2/ }.each do |r|
+            r.set("loglevel", "notice", r.source)
+        end
+
+        # And add a new resource
+        resources << mkresource(:type => "file",
+            :title => "/tmp/file_added",
+            :params => {:owner => "user_added"})
+
+        # And change some facts
+        facts["test2"] = "yaytest"
+        facts["test3"] = "funtest"
+        facts.delete("test1")
+        host = nil
+        assert_nothing_raised {
+            host = Puppet::Rails::Host.store(
+                :resources => resources,
+                :facts => facts,
+                :name => facts["hostname"],
+                :classes => ["one", "two::three", "four"]
+            )
+        }
+
+        # Make sure it sets the last_compile time
+        assert_nothing_raised do
+            assert_instance_of(Time, host.last_compile, "did not set last_compile")
+        end
+
+        assert_nil(host.fact('test1'), "removed fact was not deleted")
+        facts.each do |fact, value|
+            assert_equal(value, host.fact(fact), "fact %s is wrong" % fact)
+        end
+
+        # And check the changes we made.
+        assert(! host.resources.find(:all).detect { |r| r.title =~ /file3/ },
+            "Removed resources are still present")
+
+        res = host.resources.find_by_title("/tmp/file_added")
+        assert(res, "New resource was not added")
+        assert_equal("user_added", res.parameter("owner"), "user info was not stored")
+
+        # This actually works in real life, but I can't get it to work in testing.
+        # I expect it's a caching problem.
+        count = 0
+        host.resources.find(:all).find_all { |r| r.title =~ /file2/ }.each do |r|
+            r.save
+            puts "%s => %s" % [r.ref, r.parameters.inspect]
+            assert_equal("notice", r.parameter("loglevel"),
+                "loglevel was not added")
+            case r.restype
+            when "file":
+                assert_equal("fake", r.parameter("owner"), "owner was not modified")
+            when "exec":
+                assert_equal("fake", r.parameter("user"), "user was not modified")
+            else
+                raise "invalid resource type %s" % r.restype
+            end
+        end
+    end
+    else
+        $stderr.puts "Install Rails for Rails and Caching tests"
+    end
+end
+
+# $Id: host.rb 2296 2007-03-18 22:48:57Z luke $