puppet 0.9.2

data/test/parser/parser.rb

@@ -0,0 +1,180 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/parser/parser'
+require 'test/unit'
+require 'puppettest'
+
+class TestParser < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        Puppet[:parseonly] = true
+        #@lexer = Puppet::Parser::Lexer.new()
+        @parser = Puppet::Parser::Parser.new()
+    end
+
+    def test_each_file
+        textfiles { |file|
+            Puppet.debug("parsing %s" % file) if __FILE__ == $0
+            assert_nothing_raised() {
+                @parser.file = file
+                @parser.parse
+            }
+
+            Puppet::Type.eachtype { |type|
+                type.each { |obj|
+                    assert(obj.file)
+                    assert(obj.name)
+                    assert(obj.line)
+                }
+            }
+            Puppet::Type.allclear
+        }
+    end
+
+    def test_failers
+        failers { |file|
+            Puppet.debug("parsing failer %s" % file) if __FILE__ == $0
+            assert_raise(Puppet::ParseError) {
+                @parser.file = file
+                @parser.parse
+            }
+            Puppet::Type.allclear
+        }
+    end
+
+    def test_arrayrvalues
+        parser = Puppet::Parser::Parser.new()
+        ret = nil
+        assert_nothing_raised {
+            parser.string = 'file { "/tmp/testing": mode => [755, 640] }'
+        }
+
+        assert_nothing_raised {
+            ret = parser.parse
+        }
+    end
+
+    def mkmanifest(file)
+        name = File.join(tmpdir, "file%s" % rand(100))
+        @@tmpfiles << name
+
+        File.open(file, "w") { |f|
+            f.puts "file { \"%s\": create => true, mode => 755 }\n" %
+               name
+        }
+    end
+
+    def test_importglobbing
+        basedir = File.join(tmpdir(), "importesting")
+        @@tmpfiles << basedir
+        Dir.mkdir(basedir)
+
+        subdir = "subdir"
+        Dir.mkdir(File.join(basedir, subdir))
+        manifest = File.join(basedir, "manifest")
+        File.open(manifest, "w") { |f|
+            f.puts "import \"%s/*\"" % subdir
+        }
+
+        4.times { |i|
+            path = File.join(basedir, subdir, "subfile%s" % i)
+            mkmanifest(path)
+        }
+
+        assert_nothing_raised("Could not parse multiple files") {
+            parser = Puppet::Parser::Parser.new()
+            parser.file = manifest
+            parser.parse
+        }
+    end
+
+    def test_zdefaults
+        basedir = File.join(tmpdir(), "defaulttesting")
+        @@tmpfiles << basedir
+        Dir.mkdir(basedir)
+
+        defs1 = {
+            "testing" => "value"
+        }
+
+        defs2 = {
+            "one" => "two",
+            "three" => "four",
+            "five" => false,
+            "seven" => "eight",
+            "nine" => true,
+            "eleven" => "twelve"
+        }
+
+        mkdef = proc { |hash|
+            hash.collect { |arg, value|
+                "%s = %s" % [arg, value]
+            }.join(", ")
+        }
+        manifest = File.join(basedir, "manifest")
+        File.open(manifest, "w") { |f|
+            f.puts "
+    define method(#{mkdef.call(defs1)}, other) {
+        $variable = $testing
+    }
+
+    define othermethod(#{mkdef.call(defs2)}, goodness) {
+        $more = less
+    }
+
+    method {
+        other => yayness
+    }
+
+    othermethod {
+        goodness => rahness
+    }
+"
+        }
+
+        ast = nil
+        assert_nothing_raised("Could not parse multiple files") {
+            parser = Puppet::Parser::Parser.new()
+            parser.file = manifest
+            ast = parser.parse
+        }
+
+        assert(ast, "Did not receive AST while parsing defaults")
+
+        scope = nil
+        assert_nothing_raised("Could not evaluate defaults parse tree") {
+            scope = Puppet::Parser::Scope.new()
+            objects = scope.evaluate(ast)
+        }
+
+        method = nil
+        othermethod = nil
+        assert_nothing_raised {
+            method = scope.find { |child|
+                child.is_a?(Puppet::Parser::Scope) and child.type == "method"
+            }
+            defs1.each { |var, value|
+                curval = method.lookupvar(var)
+                assert_equal(value, curval, "Did not get default")
+            }
+        }
+
+        assert_nothing_raised {
+            method = scope.find { |child|
+                child.is_a?(Puppet::Parser::Scope) and child.type == "othermethod"
+            }
+            defs2.each { |var, value|
+                curval = method.lookupvar(var)
+                assert_equal(value, curval, "Did not get default")
+            }
+        }
+    end
+end
+
+# $Id: parser.rb 724 2005-10-22 22:27:20Z luke $

data/test/puppet/conffiles.rb

@@ -0,0 +1,104 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = ".."
+end
+
+require 'puppet'
+require 'puppet/config'
+require 'puppettest'
+require 'test/unit'
+
+class TestConfFiles < Test::Unit::TestCase
+    include TestPuppet
+
+    @@gooddata = [
+        {
+            "fun" => {
+                "a" => "b",
+                "c" => "d",
+                "e" => "f"
+            },
+            "yay" => {
+                "aa" => "bk",
+                "ca" => "dk",
+                "ea" => "fk"
+            },
+            "boo" => {
+                "eb" => "fb"
+            },
+            "rah" => {
+                "aa" => "this is a sentence",
+                "ca" => "dk",
+                "ea" => "fk"
+            },
+        },
+        {
+            "puppet" => {
+                "yay" => "rah"
+            },
+            "booh" => {
+                "okay" => "rah"
+            },
+            "back" => {
+                "okay" => "rah"
+            },
+        }
+    ]
+
+    def data2config(data)
+        str = ""
+
+        if data.include?("puppet")
+            # because we're modifying it
+            data = data.dup
+            str += "[puppet]\n"
+            data["puppet"].each { |var, value|
+                str += "%s %s\n" % [var, value]
+            }
+            data.delete("puppet")
+        end
+
+        data.each { |type, settings|
+            str += "[%s]\n" % type
+            settings.each { |var, value|
+                str += "%s %s\n" % [var, value]
+            }
+        }
+
+        return str
+    end
+
+    def sampledata
+        if block_given?
+            @@gooddata.each { |hash| yield hash }
+        else
+            return @@gooddata[0]
+        end
+    end
+
+    def test_readconfig
+        path = tempfile()
+
+        sampledata { |data|
+            # Write it out as a config file
+            File.open(path, "w") { |f| f.print data2config(data) }
+            config = nil
+            assert_nothing_raised {
+                config = Puppet::Config.new(path)
+            }
+
+            data.each { |section, hash|
+                hash.each { |var, value|
+                    assert_equal(
+                        data[section][var],
+                        config[section][var],
+                        "Got different values at %s/%s" % [section, var]
+                    )
+                }
+            }
+        }
+    end
+end
+
+# $Id: conffiles.rb 738 2005-10-31 22:50:09Z luke $

data/test/puppet/defaults.rb

@@ -0,0 +1,100 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = ".."
+end
+
+require 'puppet'
+require 'test/unit'
+
+# $Id: defaults.rb 724 2005-10-22 22:27:20Z luke $
+
+class TestPuppetDefaults < Test::Unit::TestCase
+    @@dirs = %w{rrddir puppetconf puppetvar logdir statedir}
+    @@files = %w{logfile checksumfile manifest masterlog}
+    @@normals = %w{puppetport masterport server}
+    @@booleans = %w{rrdgraph noop}
+
+    def testVersion
+        assert( Puppet.version =~ /^[0-9]+(\.[0-9]+)*$/ )
+    end
+
+    def testStringOrParam
+        [@@dirs,@@files,@@booleans].flatten.each { |param|
+            assert_nothing_raised { Puppet[param] }
+            assert_nothing_raised { Puppet[param.intern] }
+        }
+    end
+
+    def test_valuesForEach
+        [@@dirs,@@files,@@booleans].flatten.each { |param|
+            param = param.intern
+            assert_nothing_raised { Puppet[param] }
+        }
+    end
+
+    def testValuesForEach
+        [@@dirs,@@files,@@booleans].flatten.each { |param|
+            assert_nothing_raised { Puppet[param] }
+        }
+    end
+
+    if __FILE__ == $0
+        def disabled_testContained
+            confdir = Regexp.new(Puppet[:puppetconf])
+            vardir = Regexp.new(Puppet[:puppetvar])
+            [@@dirs,@@files].flatten.each { |param|
+                value = Puppet[param]
+
+                unless value =~ confdir or value =~ vardir
+                    assert_nothing_raised { raise "%s is in wrong dir: %s" %
+                        [param,value] }
+                end
+            }
+        end
+    end
+
+    def testArgumentTypes
+        assert_raise(ArgumentError) { Puppet[["string"]] }
+        assert_raise(ArgumentError) { Puppet[[:symbol]] }
+    end
+
+    def testFailOnBogusArgs
+        [0, "ashoweklj", ";", :thisisafakesymbol].each { |param|
+            assert_raise(ArgumentError) { Puppet[param] }
+        }
+    end
+
+    # we don't want user defaults in /, or root defaults in ~
+    def testDefaultsInCorrectRoots
+        notval = nil
+        if Process.uid == 0
+            notval = Regexp.new(File.expand_path("~"))
+        else
+            notval = /^\/var|^\/etc/
+        end
+        [@@dirs,@@files].flatten.each { |param|
+            value = Puppet[param]
+
+            unless value !~ notval
+                assert_nothing_raised { raise "%s is in wrong dir: %s" %
+                    [param,value] }
+            end
+        }
+    end
+
+    def test_settingdefaults
+        testvals = {
+            :fakeparam => [:puppetconf, "yaytest"],
+            :anotherparam => proc { File.join(Puppet[:puppetvar], "goodtest") },
+            :string => "a yay string",
+            :boolean => true
+        }
+
+        testvals.each { |param, default|
+            assert_nothing_raised {
+                Puppet.setdefault(param,default)
+            }
+        }
+    end
+end

data/test/puppet/error.rb

@@ -0,0 +1,23 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestError < Test::Unit::TestCase
+    include TestPuppet
+
+    def test_errorisstring
+        error = nil
+        assert_nothing_raised {
+            error = Puppet::ParseError.new("This is an error")
+        }
+        assert_instance_of(String, error.to_s)
+    end
+end
+
+# $Id: error.rb 740 2005-11-01 20:22:19Z luke $

data/test/puppet/utiltest.rb

@@ -0,0 +1,120 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = ".."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestPuppetUtil < Test::Unit::TestCase
+    include TestPuppet
+    unless Process.uid == 0
+        $stderr.puts "Run as root to perform Utility tests"
+    else
+
+    def mknverify(file, user, group = nil, id = false)
+        if File.exists?(file)
+            File.unlink(file)
+        end
+        args = []
+        unless user or group
+            args << nil
+        end
+        if user
+            if id
+                args << user.uid
+            else
+                args << user.name
+            end
+        end
+
+        if group
+            if id
+                args << group.gid
+            else
+                args << group.name
+            end
+        end
+
+        gid = nil
+        if group
+            gid = group.gid
+        else
+            gid = Process.gid
+        end
+
+        uid = nil
+        if user
+            uid = user.uid
+        else
+            uid = Process.uid
+        end
+
+        assert_nothing_raised {
+            Puppet::Util.asuser(*args) {
+                assert_equal(Process.euid, uid, "UID is %s instead of %s" %
+                    [Process.euid, uid]
+                )
+                assert_equal(Process.egid, gid, "GID is %s instead of %s" %
+                    [Process.egid, gid]
+                )
+                system("touch %s" % file)
+            }
+        }
+        if uid == 0
+            #Puppet.warning "Not testing user"
+        else
+            #Puppet.warning "Testing user %s" % uid
+            assert(File.exists?(file), "File does not exist")
+            assert_equal(File.stat(file).uid, uid,
+                "File is owned by %s instead of %s" %
+                [File.stat(file).uid, uid]
+            )
+            #system("ls -l %s" % file)
+        end
+        if gid == 0
+            #Puppet.warning "Not testing group"
+        else
+            #Puppet.warning "Testing group %s" % gid
+            assert_equal(File.stat(file).gid, gid,
+                "File group is %s instead of %s" %
+                [File.stat(file).gid, gid]
+            )
+            #system("ls -l %s" % file)
+        end
+        assert_nothing_raised {
+            File.unlink(file)
+        }
+    end
+
+    def test_asuser
+        file = File.join(tmpdir, "asusertest")
+        @@tmpfiles << file
+        [
+            [nil], # Nothing
+            [nonrootuser()], # just user, by name
+            [nonrootuser(), nil, true], # user, by uid
+            [nonrootuser(), nonrootgroup()], # user and group, by name
+            [nonrootuser(), nonrootgroup(), true], # user and group, by id
+        ].each { |ary|
+            mknverify(file, *ary)
+        }
+    end
+
+    # Verify that we get reset back to the right user
+    def test_asuser_recovery
+        begin
+            Puppet::Util.asuser(nonrootuser()) {
+                raise "an error"
+            }
+        rescue
+        end
+
+        assert(Process.euid == 0, "UID did not get reset")
+    end
+    end
+end
+
+# $Id: utiltest.rb 743 2005-11-16 21:39:31Z luke $