puppet 0.18.4 → 0.22.4

data/test/util/classgen.rb

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppettest'
+
+class TestPuppetUtilClassGen < Test::Unit::TestCase
+    include PuppetTest
+
+    class FakeBase
+        class << self
+            attr_accessor :name
+        end
+    end
+
+    class GenTest
+        class << self
+            include Puppet::Util::ClassGen
+        end
+    end
+
+    def testclasses(name)
+        sub = Class.new(GenTest) do @name = "base#{name.to_s}" end
+        self.class.const_set("Base#{name.to_s}", sub)
+
+        klass = Class.new(FakeBase) do @name = "gen#{name.to_s}"end
+
+        return sub, klass
+    end
+
+    def test_handleclassconst
+        sub, klass = testclasses("const")
+        const = nil
+        assert_nothing_raised do
+            const = sub.send(:handleclassconst, klass, klass.name, {})
+        end
+
+        # make sure the constant is set
+        assert(defined?(Baseconst::Genconst), "const was not defined")
+        assert_equal(Baseconst::Genconst.object_id, klass.object_id)
+
+        # Now make sure don't replace by default
+        newklass = Class.new(FakeBase) do @name = klass.name end
+        assert_raise(Puppet::ConstantAlreadyDefined) do
+            const = sub.send(:handleclassconst, newklass, klass.name, {})
+        end
+        assert_equal(Baseconst::Genconst.object_id, klass.object_id)
+
+        # Now make sure we can replace it
+        assert_nothing_raised do
+            const = sub.send(:handleclassconst, newklass, klass.name, :overwrite => true)
+        end
+        assert_equal(Baseconst::Genconst.object_id, newklass.object_id)
+
+        # Now make sure we can choose our own constant
+        assert_nothing_raised do
+            const = sub.send(:handleclassconst, newklass, klass.name,
+                :constant => "Fooness")
+        end
+        assert(defined?(Baseconst::Fooness), "Specified constant was not defined")
+
+        # And make sure prefixes work
+        assert_nothing_raised do
+            const = sub.send(:handleclassconst, newklass, klass.name,
+                :prefix => "Test")
+        end
+        assert(defined?(Baseconst::TestGenconst), "prefix was not used")
+    end
+
+    def test_initclass_preinit
+        sub, klass = testclasses("preinit")
+
+        class << klass
+            attr_accessor :set
+            def preinit
+                @set = true
+            end
+        end
+
+        assert(!klass.set, "Class was already initialized")
+
+        assert_nothing_raised do sub.send(:initclass, klass, {}) end
+
+        assert(klass.set, "Class was not initialized")
+    end
+
+    def test_initclass_initvars
+        sub, klass = testclasses("initvars")
+
+        class << klass
+            attr_accessor :set
+            def initvars
+                @set = true
+            end
+        end
+
+        assert(!klass.set, "Class was already initialized")
+
+        assert_nothing_raised do sub.send(:initclass, klass, {}) end
+
+        assert(klass.set, "Class was not initialized")
+    end
+
+    def test_initclass_attributes
+        sub, klass = testclasses("attributes")
+
+        class << klass
+            attr_accessor :one, :two, :three
+        end
+
+        assert(!klass.one, "'one' was already set")
+
+        assert_nothing_raised do sub.send(:initclass, klass,
+            :attributes => {:one => :a, :two => :b}) end
+
+        assert_equal(:a, klass.one, "Class was initialized incorrectly")
+        assert_equal(:b, klass.two, "Class was initialized incorrectly")
+        assert_nil(klass.three, "Class was initialized incorrectly")
+    end
+
+    def test_initclass_include_and_extend
+        sub, klass = testclasses("include_and_extend")
+
+        incl = Module.new do
+            attr_accessor :included
+        end
+        self.class.const_set("Incl", incl)
+
+        ext = Module.new do
+            attr_accessor :extended
+        end
+        self.class.const_set("Ext", ext)
+
+        assert(! klass.respond_to?(:extended), "Class already responds to extended")
+        assert(! klass.new.respond_to?(:included), "Class already responds to included")
+
+        assert_nothing_raised do sub.send(:initclass, klass,
+            :include => incl, :extend => ext)
+        end
+
+        assert(klass.respond_to?(:extended), "Class did not get extended")
+        assert(klass.new.respond_to?(:included), "Class did not include")
+    end
+
+    def test_genclass
+        hash = {}
+        array = []
+
+        name = "yayness"
+        klass = nil
+        assert_nothing_raised {
+            klass = GenTest.genclass(name, :array => array,
+                :hash => hash, :parent => FakeBase) do
+                    class << self
+                        attr_accessor :name
+                    end
+            end
+        }
+
+        assert(klass.respond_to?(:name=), "Class did not execute block")
+
+        assert(hash.include?(klass.name),
+            "Class did not get added to hash")
+        assert(array.include?(klass),
+            "Class did not get added to array")
+        assert_equal(klass.superclass, FakeBase, "Parent class was wrong")
+    end
+
+    # Make sure we call a preinithook, if there is one.
+    def test_inithooks
+        newclass = Class.new(FakeBase) do
+            class << self
+                attr_accessor :preinited, :postinited
+            end
+            def self.preinit
+                self.preinited = true
+            end
+            def self.postinit
+                self.postinited = true
+            end
+        end
+
+        klass = nil
+        assert_nothing_raised {
+            klass = GenTest.genclass(:funtest, :parent => newclass)
+        }
+
+        assert(klass.preinited, "prehook did not get called")
+        assert(klass.postinited, "posthook did not get called")
+    end
+
+    def test_modulegen
+        hash = {}
+        array = []
+
+        name = "modness"
+        mod = nil
+        assert_nothing_raised {
+            mod = GenTest.genmodule(name, :array => array, :hash => hash) do
+                class << self
+                    attr_accessor :yaytest
+                end
+
+                @yaytest = true
+            end
+        }
+
+        assert(mod.respond_to?(:yaytest), "Class did not execute block")
+
+        assert_instance_of(Module, mod)
+        assert(hash.include?(mod.name),
+            "Class did not get added to hash")
+        assert(array.include?(mod),
+            "Class did not get added to array")
+    end
+
+    def test_genconst_string
+        const = nil
+        assert_nothing_raised do
+            const = GenTest.send(:genconst_string, :testing, :prefix => "Yayness")
+        end
+        assert_equal("YaynessTesting", const)
+    end
+end
+
+# $Id: classgen.rb 1856 2006-11-11 07:40:16Z luke $

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

@@ -1,18 +1,21 @@
 #!/usr/bin/env ruby
 
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
-require 'puppet/config'
+require 'puppet/util/config'
 require 'puppettest'
-require 'test/unit'
+require 'puppettest/parsertesting'
 
 class TestConfig < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
+	include PuppetTest::ParserTesting
+
+    def setup
+        super
+        @config = mkconfig
+    end
+
 
     def check_for_users
         count = Puppet::Type.type(:user).inject(0) { |c,o|
@@ -46,21 +49,16 @@ class TestConfig < Test::Unit::TestCase
         }
 
         Puppet[:parseonly] = true
-        parser = Puppet::Parser::Parser.new()
 
-        objects = nil
-        assert_nothing_raised("Could not parse generated manifest") {
-            parser.string = manifest
-            objects = parser.parse
-        }
-        scope = Puppet::Parser::Scope.new
-        assert_nothing_raised("Could not compile objects") {
-            scope.evaluate(:ast => objects)
-        }
+        interp = nil
+        assert_nothing_raised do
+            interp = mkinterp :Code => manifest, :UseNodes => false
+        end
+
         trans = nil
-        assert_nothing_raised("Could not convert objects to transportable") {
-            trans = scope.to_trans
-        }
+        assert_nothing_raised do
+            trans = interp.evaluate(nil, {})
+        end
         assert_nothing_raised("Could not instantiate objects") {
             trans.to_type
         }
@@ -95,63 +93,60 @@ class TestConfig < Test::Unit::TestCase
     def mkconfig
         c = nil
         assert_nothing_raised {
-            c = Puppet::Config.new
+            c = Puppet::Util::Config.new
         }
         return c
     end
 
     def test_addbools
-        c = mkconfig
-
         assert_nothing_raised {
-            c.setdefaults(:testing, :booltest => [true, "testing"])
+            @config.setdefaults(:testing, :booltest => [true, "testing"])
         }
 
-        assert(c[:booltest])
-        c = mkconfig
+        assert(@config[:booltest])
+        @config = mkconfig
 
         assert_nothing_raised {
-            c.setdefaults(:testing, :booltest => ["true", "testing"])
+            @config.setdefaults(:testing, :booltest => ["true", "testing"])
         }
 
-        assert(c[:booltest])
+        assert(@config[:booltest])
 
         assert_nothing_raised {
-            c[:booltest] = false
+            @config[:booltest] = false
         }
 
-        assert(! c[:booltest], "Booltest is not false")
+        assert(! @config[:booltest], "Booltest is not false")
 
         assert_nothing_raised {
-            c[:booltest] = "false"
+            @config[:booltest] = "false"
         }
 
-        assert(! c[:booltest], "Booltest is not false")
+        assert(! @config[:booltest], "Booltest is not false")
 
         assert_raise(Puppet::Error) {
-            c[:booltest] = "yayness"
+            @config[:booltest] = "yayness"
         }
 
         assert_raise(Puppet::Error) {
-            c[:booltest] = "/some/file"
+            @config[:booltest] = "/some/file"
         }
     end
 
     def test_strings
-        c = mkconfig
         val = "this is a string"
         assert_nothing_raised {
-            c.setdefaults(:testing, :strtest => [val, "testing"])
+            @config.setdefaults(:testing, :strtest => [val, "testing"])
         }
 
-        assert_equal(val, c[:strtest])
+        assert_equal(val, @config[:strtest])
 
         # Verify that variables are interpolated
         assert_nothing_raised {
-            c.setdefaults(:testing, :another => ["another $strtest", "testing"])
+            @config.setdefaults(:testing, :another => ["another $strtest", "testing"])
         }
 
-        assert_equal("another #{val}", c[:another])
+        assert_equal("another #{val}", @config[:another])
     end
 
     def test_files
@@ -159,47 +154,46 @@ class TestConfig < Test::Unit::TestCase
 
         parent = "/puppet"
         assert_nothing_raised {
-            c.setdefaults(:testing, :parentdir => [parent, "booh"])
+            @config.setdefaults(:testing, :parentdir => [parent, "booh"])
         }
 
         assert_nothing_raised {
-            c.setdefaults(:testing, :child => ["$parent/child", "rah"])
+            @config.setdefaults(:testing, :child => ["$parent/child", "rah"])
         }
 
-        assert_equal(parent, c[:parentdir])
-        assert_equal("/puppet/child", File.join(c[:parentdir], "child"))
+        assert_equal(parent, @config[:parentdir])
+        assert_equal("/puppet/child", File.join(@config[:parentdir], "child"))
     end
 
     def test_getset
-        c = mkconfig
         initial = "an initial value"
         assert_raise(Puppet::Error) {
-            c[:yayness] = initial
+            @config[:yayness] = initial
         }
 
         default = "this is a default"
         assert_nothing_raised {
-            c.setdefaults(:testing, :yayness => [default, "rah"])
+            @config.setdefaults(:testing, :yayness => [default, "rah"])
         }
 
-        assert_equal(default, c[:yayness])
+        assert_equal(default, @config[:yayness])
 
         assert_nothing_raised {
-            c[:yayness] = initial
+            @config[:yayness] = initial
         }
 
-        assert_equal(initial, c[:yayness])
+        assert_equal(initial, @config[:yayness])
 
         assert_nothing_raised {
-            c.clear
+            @config.clear
         }
 
-        assert_equal(default, c[:yayness])
+        assert_equal(default, @config[:yayness])
 
         assert_nothing_raised {
-            c[:yayness] = "not default"
+            @config[:yayness] = "not default"
         }
-        assert_equal("not default", c[:yayness])
+        assert_equal("not default", @config[:yayness])
     end
 
     def test_parse
@@ -221,9 +215,8 @@ yay = /a/path
         file = tempfile()
         File.open(file, "w") { |f| f.puts text }
 
-        c = mkconfig
         assert_nothing_raised {
-            c.setdefaults("puppet",
+            @config.setdefaults("puppet",
                 :one => ["a", "one"],
                 :two => ["a", "two"],
                 :yay => ["/default/path", "boo"],
@@ -232,7 +225,7 @@ yay = /a/path
         }
 
         assert_nothing_raised {
-            c.setdefaults("section1",
+            @config.setdefaults("section1",
                 :attr => ["a", "one"],
                 :attrdir => ["/another/dir", "two"],
                 :attr3 => ["$attrdir/maybe", "boo"]
@@ -240,17 +233,17 @@ yay = /a/path
         }
         
         assert_nothing_raised {
-            c.parse(file)
+            @config.parse(file)
         }
 
-        assert_equal("value", c[:attr])
-        assert_equal("/some/dir", c[:attrdir])
-        assert_equal(:directory, c.element(:attrdir).type)
-        assert_equal("/some/dir/other", c[:attr3])
+        assert_equal("value", @config[:attr])
+        assert_equal("/some/dir", @config[:attrdir])
+        assert_equal(:directory, @config.element(:attrdir).type)
+        assert_equal("/some/dir/other", @config[:attr3])
 
         elem = nil
         assert_nothing_raised {
-            elem = c.element(:attr3)
+            elem = @config.element(:attr3)
         }
 
         assert(elem)
@@ -258,27 +251,27 @@ yay = /a/path
 
         config = nil
         assert_nothing_raised {
-            config = c.to_config
+            config = @config.to_config
         }
 
         assert_nothing_raised("Could not create transportable config") {
-            c.to_transportable
+            @config.to_transportable
         }
 
-        check_to_comp(c)
+        check_to_comp(@config)
         Puppet::Type.allclear
-        check_to_manifest(c)
+        check_to_manifest(@config)
         Puppet::Type.allclear
-        check_to_config(c)
+        check_to_config(@config)
         Puppet::Type.allclear
-        check_to_transportable(c)
+        check_to_transportable(@config)
     end
 
     def test_arghandling
         c = mkconfig
 
         assert_nothing_raised {
-            c.setdefaults("testing",
+            @config.setdefaults("testing",
                 :onboolean => [true, "An on bool"],
                 :offboolean => [false, "An off bool"],
                 :string => ["a string", "A string arg"],
@@ -296,7 +289,7 @@ yay = /a/path
             values.each { |val|
                 opt = nil
                 arg = nil
-                if c.boolean?(param)
+                if @config.boolean?(param)
                     if val
                         opt = "--%s" % param
                     else
@@ -310,7 +303,7 @@ yay = /a/path
                 assert_nothing_raised("Could not handle arg %s with value %s" %
                     [opt, val]) {
 
-                    c.handlearg(opt, arg)
+                    @config.handlearg(opt, arg)
                 }
             }
         }
@@ -320,7 +313,7 @@ yay = /a/path
         c = mkconfig
 
         assert_nothing_raised {
-            c.setdefaults("testing",
+            @config.setdefaults("testing",
                 :onboolean => [true, "An on bool"],
                 :offboolean => [false, "An off bool"],
                 :string => ["a string", "A string arg"],
@@ -329,15 +322,15 @@ yay = /a/path
         }
         options = []
 
-        c.addargs(options)
+        @config.addargs(options)
 
-        c.each { |param, obj|
+        @config.each { |param, obj|
             opt = "--%s" % param
             assert(options.find { |ary|
                 ary[0] == opt
             }, "Argument %s was not added" % opt)
 
-            if c.boolean?(param)
+            if @config.boolean?(param)
                 o = "--no-%s" % param
                 assert(options.find { |ary|
                 ary[0] == o
@@ -347,6 +340,10 @@ yay = /a/path
     end
 
     def test_usesection
+        # We want to make sure that config processes do not result in graphing.
+        Puppet[:graphdir] = tempfile()
+        Puppet[:graph] = true
+        Dir.mkdir(Puppet[:graphdir])
         c = mkconfig
 
         dir = tempfile()
@@ -355,7 +352,7 @@ yay = /a/path
         otherfile = File.join(dir, "otherfile")
         section = "testing"
         assert_nothing_raised {
-            c.setdefaults(section,
+            @config.setdefaults(section,
                 :mydir => [dir, "A dir arg"],
                 :otherfile => {
                     :default => "$mydir/otherfile",
@@ -367,12 +364,16 @@ yay = /a/path
         }
 
         assert_nothing_raised("Could not use a section") {
-            c.use(section)
+            @config.use(section)
         }
 
         assert_nothing_raised("Could not reuse a section") {
-            c.use(section)
+            @config.use(section)
         }
+        
+        # Make sure it didn't graph anything, which is the only real way
+        # to test that the transaction was marked as a configurator.
+        assert(Dir.entries(Puppet[:graphdir]).reject { |f| f =~ /^\.\.?$/ }.empty?, "Graphed config process")
 
         assert(FileTest.directory?(dir), "Did not create directory")
         assert(FileTest.exists?(otherfile), "Did not create file")
@@ -383,28 +384,28 @@ yay = /a/path
         c = mkconfig
 
         assert_nothing_raised {
-            c.setdefaults("yay",
+            @config.setdefaults("yay",
                 :a => [false, "some value"],
                 :b => ["/my/file", "a file"]
             )
         }
 
-        assert_equal(false, c[:a], "Values are not equal")
-        assert_equal("/my/file", c[:b], "Values are not equal")
+        assert_equal(false, @config[:a], "Values are not equal")
+        assert_equal("/my/file", @config[:b], "Values are not equal")
     end
 
     def test_setdefaultshash
         c = mkconfig
 
         assert_nothing_raised {
-            c.setdefaults("yay",
+            @config.setdefaults("yay",
                 :a => {:default => false, :desc => "some value"},
                 :b => {:default => "/my/file", :desc => "a file"}
             )
         }
 
-        assert_equal(false, c[:a], "Values are not equal")
-        assert_equal("/my/file", c[:b], "Values are not equal")
+        assert_equal(false, @config[:a], "Values are not equal")
+        assert_equal("/my/file", @config[:b], "Values are not equal")
     end
 
     def test_reuse
@@ -413,13 +414,13 @@ yay = /a/path
         file = tempfile()
         section = "testing"
         assert_nothing_raised {
-            c.setdefaults(section,
-                :myfile => {:default => file, :create => true}
+            @config.setdefaults(section,
+                :myfile => {:default => file, :create => true, :desc => "yay"}
             )
         }
 
         assert_nothing_raised("Could not use a section") {
-            c.use(section)
+            @config.use(section)
         }
 
         assert(FileTest.exists?(file), "Did not create file")
@@ -428,7 +429,7 @@ yay = /a/path
 
         File.unlink(file)
 
-        c.reuse
+        @config.reuse
         assert(FileTest.exists?(file), "Did not create file")
     end
 
@@ -438,12 +439,13 @@ yay = /a/path
         file = tempfile()
         section = "testing"
         assert_nothing_raised {
-            c.setdefaults(section,
+            @config.setdefaults(section,
                 :mkusers => [false, "yay"],
                 :myfile => {
                     :default => file,
                     :owner => "pptest",
                     :group => "pptest",
+                    :desc => "yay",
                     :create => true
                 }
             )
@@ -451,7 +453,7 @@ yay = /a/path
 
         comp = nil
         assert_nothing_raised {
-            comp = c.to_component
+            comp = @config.to_component
         }
 
         [:user, :group].each do |type|
@@ -463,26 +465,38 @@ yay = /a/path
         end
         comp.each { |o| o.remove }
 
-        c[:mkusers] = true
+        @config[:mkusers] = true
 
         assert_nothing_raised {
-            c.to_component
+            @config.to_component
         }
 
-        assert(Puppet.type(:user)["pptest"], "User object did not get created")
-        assert(Puppet.type(:user)["pptest"].managed?,
-            "User object is not managed."
-        )
-        assert(Puppet.type(:group)["pptest"], "Group object did not get created")
-        assert(Puppet.type(:group)["pptest"].managed?,
+        user = Puppet.type(:user)["pptest"]
+        assert(user, "User object did not get created")
+        assert(user.managed?, "User object is not managed.")
+        assert(user.should(:comment), "user does not have a comment set")
+        
+        group = Puppet.type(:group)["pptest"]
+        assert(group, "Group object did not get created")
+        assert(group.managed?,
             "Group object is not managed."
         )
+        
+        if Process.uid == 0
+            cleanup do
+                user[:ensure] = :absent
+                group[:ensure] = :absent
+                assert_apply(user, group)
+            end
+            
+            assert_apply(user, group)
+        end
     end
 
     def test_notmanagingdev
         c = mkconfig
         path = "/dev/testing"
-        c.setdefaults(:test,
+        @config.setdefaults(:test,
             :file => {
                 :default => path,
                 :mode => 0640,
@@ -491,7 +505,7 @@ yay = /a/path
         )
 
         assert_nothing_raised {
-            c.to_component
+            @config.to_component
         }
 
         assert(! Puppet.type(:file)["/dev/testing"], "Created dev file")
@@ -503,13 +517,13 @@ yay = /a/path
         group = "yayness"
 
         File.open(cfile, "w") do |f|
-            f.puts "[#{Puppet.name}]
+            f.puts "[#{Puppet[:name]}]
             group = #{group}
             "
         end
 
         config = mkconfig
-        config.setdefaults(Puppet.name, :group => ["puppet", "a group"])
+        config.setdefaults(Puppet[:name], :group => ["puppet", "a group"])
 
         assert_nothing_raised {
             config.parse(cfile)
@@ -521,17 +535,19 @@ yay = /a/path
     # provide a method to modify and create files w/out specifying the info
     # already stored in a config
     def test_writingfiles
+        File.umask(0022)
+      
         path = tempfile()
         mode = 0644
 
         config = mkconfig
 
-        args = { :default => path, :mode => mode }
+        args = { :default => path, :mode => mode, :desc => "yay" }
 
         user = nonrootuser()
         group = nonrootgroup()
 
-        if Process.uid == 0
+        if Puppet::Util::SUIDManager.uid == 0
             args[:owner] = user.name
             args[:group] = group.name
         end
@@ -547,7 +563,7 @@ yay = /a/path
         assert_equal(mode, filemode(path), "Modes are not equal")
 
         # OS X is broken in how it chgrps files 
-        if Process.uid == 0
+        if Puppet::Util::SUIDManager.uid == 0
             assert_equal(user.uid, File.stat(path).uid, "UIDS are not equal")
 
             case Facter["operatingsystem"].value
@@ -559,17 +575,19 @@ yay = /a/path
     end
 
     def test_mkdir
+        File.umask(0022)
+        
         path = tempfile()
         mode = 0755
 
         config = mkconfig
 
-        args = { :default => path, :mode => mode }
+        args = { :default => path, :mode => mode, :desc => "a file" }
 
         user = nonrootuser()
         group = nonrootgroup()
 
-        if Process.uid == 0
+        if Puppet::Util::SUIDManager.uid == 0
             args[:owner] = user.name
             args[:group] = group.name
         end
@@ -584,7 +602,7 @@ yay = /a/path
 
 
         # OS X and *BSD is broken in how it chgrps files 
-        if Process.uid == 0
+        if Puppet::Util::SUIDManager.uid == 0
             assert_equal(user.uid, File.stat(path).uid, "UIDS are not equal")
 
             case Facter["operatingsystem"].value
@@ -665,9 +683,9 @@ inttest = 27
     def test_correct_type_assumptions
         config = mkconfig
 
-        file = Puppet::Config::CFile
-        element = Puppet::Config::CElement
-        bool = Puppet::Config::CBoolean
+        file = Puppet::Util::Config::CFile
+        element = Puppet::Util::Config::CElement
+        bool = Puppet::Util::Config::CBoolean
 
         # We have to keep these ordered, unfortunately.
         [
@@ -686,6 +704,7 @@ inttest = 27
                 elem = config.newelement(
                     :name => value,
                     :default => value,
+                    :desc => name.to_s,
                     :section => :yayness
                 )
             }
@@ -807,6 +826,247 @@ inttest = 27
 
 
     end
+
+    # Test that config parameters correctly call passed-in blocks when the value
+    # is set.
+    def test_paramblocks
+        config = mkconfig()
+
+        testing = nil
+        elem = nil
+        assert_nothing_raised do
+            elem = config.newelement :default => "yay",
+                :name => :blocktest,
+                :desc => "boo",
+                :section => :test,
+                :hook => proc { |value| testing = value }
+        end
+
+        assert_nothing_raised do
+            assert_equal("yay", elem.value)
+        end
+
+        assert_nothing_raised do
+            elem.value = "yaytest"
+        end
+
+        assert_nothing_raised do
+            assert_equal("yaytest", elem.value)
+        end
+        assert_equal("yaytest", testing)
+
+        assert_nothing_raised do
+            elem.value = "another"
+        end
+
+        assert_nothing_raised do
+            assert_equal("another", elem.value)
+        end
+        assert_equal("another", testing)
+
+        # Now verify it works from setdefault
+        assert_nothing_raised do
+            config.setdefaults :test,
+                :blocktest2 => {
+                    :default => "yay",
+                    :desc => "yay",
+                    :hook => proc { |v| testing = v }
+                }
+        end
+
+        assert_equal("yay", config[:blocktest2])
+
+        assert_nothing_raised do
+            config[:blocktest2] = "footest"
+        end
+        assert_equal("footest", config[:blocktest2])
+        assert_equal("footest", testing)
+    end
+
+    def test_no_modify_root
+        config = mkconfig
+        config.setdefaults(:yay,
+            :mydir => {:default => tempfile(),
+                :mode => 0644,
+                :owner => "root",
+                :group => "root",
+                :desc => "yay"
+            },
+            :mkusers => [false, "yay"]
+        )
+
+        assert_nothing_raised do
+            config.use(:yay)
+        end
+
+        # Now enable it so they'll be added
+        config[:mkusers] = true
+
+        comp = config.to_component
+
+        Puppet::Type.type(:user).each do |u|
+            assert(u.name != "root", "Tried to manage root user")
+        end
+        Puppet::Type.type(:group).each do |u|
+            assert(u.name != "root", "Tried to manage root group")
+            assert(u.name != "wheel", "Tried to manage wheel group")
+        end
+
+#        assert(yay, "Did not find yay component")
+#        yay.each do |c|
+#            puts @config.ref
+#        end
+#        assert(! yay.find { |o| o.class.name == :user and o.name == "root" },
+#            "Found root user")
+#        assert(! yay.find { |o| o.class.name == :group and o.name == "root" },
+#            "Found root group")
+    end
+    
+    # #415
+    def test_remove_trailing_spaces
+        config = mkconfig()
+        config.setdefaults(:yay, :rah => ["testing", "a desc"])
+        
+        file = tempfile()
+        File.open(file, "w") { |f| f.puts "rah = something " }
+        
+        assert_nothing_raised { config.parse(file) }
+        assert_equal("something", config[:rah], "did not remove trailing whitespace in parsing")
+    end
+
+    # #484
+    def test_parsing_unknown_variables
+        logstore()
+        config = mkconfig()
+        config.setdefaults(:mysection, :one => ["yay", "yay"])
+        file = tempfile()
+        File.open(file, "w") { |f|
+            f.puts %{[mysection]\n
+                one = one
+                two = yay
+            }
+        }
+
+        assert_nothing_raised("Unknown parameter threw an exception") do
+            config.parse(file)
+        end
+
+        assert(@logs.detect { |l| l.message =~ /unknown configuration/ and l.level == :warning },
+            "Did not generate warning message")
+    end
+
+    def test_multiple_interpolations
+        @config.setdefaults(:section,
+            :one => ["oneval", "yay"],
+            :two => ["twoval", "yay"],
+            :three => ["$one/$two", "yay"]
+        )
+
+        assert_equal("oneval/twoval", @config[:three],
+            "Did not interpolate multiple variables")
+    end
+
+    # Make sure we can replace ${style} var names
+    def test_curly_replacements
+        @config.setdefaults(:section,
+            :one => ["oneval", "yay"],
+            :two => ["twoval", "yay"],
+            :three => ["$one/${two}/${one}/$two", "yay"]
+        )
+
+        assert_equal("oneval/twoval/oneval/twoval", @config[:three],
+            "Did not interpolate curlied variables")
+    end
+
+    # #489
+    def test_modes
+        Puppet[:name] = "puppet"
+        config = tempfile()
+
+        check = Proc.new do |string, int|
+            trans = @config.section_to_transportable(:puppet)
+            ssldir = trans.find { |o| o.type == "file"  }
+            assert(ssldir, "could not find trans object")
+
+            if ssldir[:mode].is_a?(Fixnum)
+                assert_equal(int, ssldir[:mode], "mode not set correctly")
+            else
+                assert_equal(string, ssldir[:mode], "mode not set correctly")
+            end
+
+            obj = nil
+            assert_nothing_raised { obj = ssldir.to_type }
+
+            assert(obj, "did not create object")
+            assert_equal(int, obj.should(:mode),
+                "did not pass mode correctly to file")
+
+            obj.class.clear
+        end
+
+        file = tempfile
+        @config.setdefaults(:puppet, :mode => ["644", "yay"])
+        @config.setdefaults(:puppet, :ssldir => {
+            :mode => 0644,
+            :desc => "yay",
+            :default => "/some/file"})
+
+        # Convert it first using the number
+        check.call("644", 0644)
+
+        File.open(config, "w") { |f| f.puts "[puppet]
+        mode = 750
+        ssldir = #{file}
+        "}
+
+        @config.parse(config)
+
+        assert_equal("750", @config[:mode],
+            "Did not parse mode correctly")
+
+        check.call("750", 0750)
+    end
+
+    def test_only_set_metas_when_valid
+        file = tempfile
+        config = tempfile
+        @config.setdefaults(Puppet[:name], :ssldir => {
+            :mode => 0644,
+            :group => "yayness",
+            :desc => "yay",
+            :default => "/some/file"})
+
+        File.open(config, "w") { |f| f.puts "[#{Puppet[:name]}]
+        mode = 755
+        group = foo
+        ssldir = #{file}
+        "}
+
+        assert_nothing_raised do
+            @config.parse(config)
+        end
+
+        assert_raise(ArgumentError) do
+            @config[:mode]
+        end
+        assert_raise(ArgumentError) do
+            @config[:group]
+        end
+
+        # Now make them valid params
+        @config.setdefaults(Puppet[:name], :group => ["blah", "yay"])
+        @config.setdefaults(Puppet[:name], :mode => ["750", "yay"])
+
+        assert_nothing_raised do
+            @config.parse(config)
+        end
+
+        assert_equal("foo", @config[:group],
+            "Did not store group when it is a valid config")
+        assert_equal("755", @config[:mode],
+            "Did not store mode when it is a valid config")
+
+    end
 end
 
-# $Id: config.rb 1420 2006-07-21 21:16:09Z luke $
+# $Id: config.rb 2273 2007-03-08 17:35:18Z luke $