puppet 0.24.9 → 0.25.0

data/test/util/inifile.rb

@@ -7,13 +7,13 @@ require 'puppet/util/inifile'
 require 'puppettest'
 
 class TestFileType < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
 
     def setup
         super
         @file = Puppet::Util::IniConfig::File.new
     end
-    
+
     def teardown
         @file = nil
         super
@@ -43,7 +43,7 @@ class TestFileType < Test::Unit::TestCase
             @file.read(fsub)
         }
         main = get_section('main')
-        assert_entries(main, 
+        assert_entries(main,
                        { 'key1' => 'main.value1', 'key2' => 'main.value2' })
         sub1 = get_section('sub1')
         assert_entries(sub1, { 'key1' => 'sub1 value1' })
@@ -106,9 +106,9 @@ class TestFileType < Test::Unit::TestCase
     end
 
     def assert_entries(section, hash)
-        hash.each do |k, v| 
-            assert_equal(v, section[k], 
-                        "Expected <#{v}> for #{section.name}[#{k}] " + 
+        hash.each do |k, v|
+            assert_equal(v, section[k],
+                        "Expected <#{v}> for #{section.name}[#{k}] " +
                          "but got <#{section[k]}>")
         end
     end

data/test/util/instance_loader.rb

@@ -7,7 +7,7 @@ require 'puppet/util/instance_loader'
 require 'puppettest'
 
 class TestInstanceloader < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
 
     def setup
         super

data/test/util/log.rb

@@ -129,7 +129,7 @@ class TestLog < Test::Unit::TestCase
     # Verify that the error and source are always strings
     def test_argsAreStrings
         msg = nil
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :path => tempfile(),
             :check => %w{owner group}
         )
@@ -195,7 +195,7 @@ class TestLog < Test::Unit::TestCase
         Puppet.warning "A test"
         assert(File.read(file) =~ /A test/,
             "File did not flush")
-        # Rename the file 
+        # Rename the file
         newfile = file + ".old"
         File.rename(file, newfile)
 

data/test/util/metrics.rb

@@ -17,7 +17,7 @@ class TestMetric < PuppetTest::TestCase
         eventmax = 10
         maxdiff = 10
 
-        types = [Puppet.type(:file), Puppet.type(:package), Puppet.type(:package)]
+        types = [Puppet::Type.type(:file), Puppet::Type.type(:package), Puppet::Type.type(:package)]
         data = [:total, :managed, :outofsync, :changed, :totalchanges]
         events = [:file_changed, :package_installed, :service_started]
 
@@ -49,11 +49,6 @@ class TestMetric < PuppetTest::TestCase
         }
     end
 
-    def setup
-        super
-        Puppet[:rrdgraph] = true
-    end
-
     def test_fakedata
         report = Puppet::Transaction::Report.new
         time = Time.now.to_i

data/test/util/package.rb

@@ -11,7 +11,7 @@ class TestPuppetUtilPackage < Test::Unit::TestCase
     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 
+        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

data/test/util/pidlock.rb

@@ -7,120 +7,120 @@ require 'fileutils'
 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
+    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/settings.rb

@@ -8,10 +8,10 @@ require 'puppet/util/settings'
 require 'puppettest/parsertesting'
 
 class TestSettings < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::ParserTesting
-    CElement = Puppet::Util::Settings::CElement
-    CBoolean = Puppet::Util::Settings::CBoolean
+    include PuppetTest
+    include PuppetTest::ParserTesting
+    Setting = Puppet::Util::Settings::Setting
+    BooleanSetting = Puppet::Util::Settings::BooleanSetting
 
     def setup
         super
@@ -42,23 +42,6 @@ class TestSettings < Test::Unit::TestCase
         assert(count > 0, "Found no users")
     end
 
-    def test_to_transportable
-        set_configs
-        trans = nil
-        assert_nothing_raised("Could not convert to a transportable") {
-            trans = @config.to_transportable
-        }
-
-        comp = nil
-        assert_nothing_raised("Could not convert transportable to component") {
-            comp = trans.to_type
-        }
-
-        assert_nothing_raised("Could not retrieve transported config") {
-            comp.retrieve
-        }
-    end
-
     def test_to_config
         set_configs
 
@@ -83,8 +66,10 @@ class TestSettings < Test::Unit::TestCase
             end
         }
 
+        newc.setdefaults :section, :config => [newfile, "eh"]
+
         assert_nothing_raised("Could not parse generated configuration") {
-            newc.parse(newfile)
+            newc.parse
         }
 
         @config.each do |name, object|
@@ -221,8 +206,6 @@ yay = /a/path
         file = tempfile()
         File.open(file, "w") { |f| f.puts text }
 
-        @config.expects(:settimer)
-        
         result = nil
         assert_nothing_raised {
             result = @config.send(:parse_file, file)
@@ -256,214 +239,6 @@ yay = /a/path
         end
     end
 
-    def test_old_parse
-        text = %{
-one = this is a test
-two = another test
-owner = root
-group = root
-yay = /a/path
-
-[section1]
-    attr = value
-    owner = puppet
-    group = puppet
-    attrdir = /some/dir
-    attr3 = $attrdir/other
-        }
-
-        file = tempfile()
-        File.open(file, "w") { |f| f.puts text }
-
-        assert_nothing_raised {
-            @config.setdefaults("puppet",
-                :one => ["a", "one"],
-                :two => ["a", "two"],
-                :yay => ["/default/path", "boo"],
-                :mkusers => [true, "uh, yeah"]
-            )
-        }
-
-        assert_nothing_raised {
-            @config.setdefaults("section1",
-                :attr => ["a", "one"],
-                :attrdir => ["/another/dir", "two"],
-                :attr3 => ["$attrdir/maybe", "boo"]
-            )
-        }
-        
-        assert_nothing_raised {
-            @config.old_parse(file)
-        }
-
-        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 = @config.element(:attr3)
-        }
-
-        assert(elem)
-        assert_equal("puppet", elem.owner)
-
-        config = nil
-        assert_nothing_raised {
-            config = @config.to_config
-        }
-
-        assert_nothing_raised("Could not create transportable config") {
-            @config.to_transportable
-        }
-    end
-
-    def test_parse
-        result = {
-            :main => {:main => "main", :bad => "invalid", :cliparam => "reset"},
-            :puppet => {:other => "puppet", :cliparam => "reset"},
-            :puppetd => {:other => "puppetd", :cliparam => "reset"}
-        }
-        # Set our defaults, so they're valid. Don't define 'bad', since we want to test for failures.
-        @config.setdefaults(:main,
-            :main => ["whatever", "a"],
-            :cliparam => ["default", "y"],
-            :other => ["a", "b"],
-            :name => ["puppet", "b"] # our default name
-        )
-        @config.setdefaults(:other,
-            :one => ["whatever", "a"],
-            :two => ["default", "y"],
-            :apple => ["a", "b"],
-            :shoe => ["puppet", "b"] # our default name
-        )
-        @config.handlearg("--cliparam", "changed")
-        @config.stubs(:parse_file).returns(result)
-
-        # First do it with our name being 'puppet'
-        assert_nothing_raised("Could not handle parse results") do
-            @config.parse(tempfile)
-        end
-
-        assert_equal(:puppet, @config.name, "Did not get correct name")
-        assert_equal("main", @config[:main], "Did not get main value")
-        assert_equal("puppet", @config[:other], "Did not get name value")
-        assert_equal("changed", @config[:cliparam], "CLI values were overridden by config")
-
-        # Now switch names and make sure the parsing switches, too.
-        @config.clear(true)
-        assert_nothing_raised("Could not handle parse results") do
-            @config.parse(tempfile)
-        end
-        @config[:name] = :puppetd
-
-        assert_equal(:puppetd, @config.name, "Did not get correct name")
-        assert_equal("main", @config[:main], "Did not get main value")
-        assert_equal("puppetd", @config[:other], "Did not get name value")
-        assert_equal("changed", @config[:cliparam], "CLI values were overridden by config")
-    end
-
-    # Make sure we can extract file options correctly.
-    def test_parsing_file_options
-        @config.setdefaults(:whev,
-            :file => {
-                :desc => "whev",
-                :default => "/default",
-                :owner => "me",
-                :group => "me",
-                :mode => "755"
-            }
-        )
-
-        file = tempfile
-        count = 0
-
-        {
-            :pass => {
-                " {owner = you}" => {:owner => "you"},
-                " {owner = you, group = you}" => {:owner => "you", :group => "you"},
-                " {owner = you, group = you, mode = 755}" => {:owner => "you", :group => "you", :mode => "755"},
-                " { owner = you, group = you } " => {:owner => "you", :group => "you"},
-                "{owner=you,group=you} " => {:owner => "you", :group => "you"},
-                "{owner=you,} " => {:owner => "you"}
-            },
-            :fail => [
-                %{{owner = you group = you}},
-                %{{owner => you, group => you}},
-                %{{user => you}},
-                %{{random => you}},
-                %{{mode => you}}, # make sure modes are numbers
-                %{{owner => you}}
-            ]
-        }.each do |type, list|
-            count += 1
-            list.each do |value|
-                if type == :pass
-                    value, should = value[0], value[1]
-                end
-                path = "/other%s" % count
-                # Write our file out
-                File.open(file, "w") do |f|
-                    f.puts %{[main]\nfile = #{path}#{value}}
-                end
-
-                if type == :fail
-                    assert_raise(ArgumentError, "Did not fail on %s" % value.inspect) do
-                        @config.send(:parse_file, file)
-                    end
-                else
-                    result = nil
-                    assert_nothing_raised("Failed to parse %s" % value.inspect) do
-                        result = @config.send(:parse_file, file)
-                    end
-                    assert_equal(should, result[:main][:_meta][:file], "Got incorrect return for %s" % value.inspect)
-                    assert_equal(path, result[:main][:file], "Got incorrect value for %s" % value.inspect)
-                end
-            end
-        end
-    end
-
-    # Make sure file options returned from parse_file are handled correctly.
-    def test_parsed_file_options
-        @config.setdefaults(:whev,
-            :file => {
-                :desc => "whev",
-                :default => "/default",
-                :owner => "me",
-                :group => "me",
-                :mode => "755"
-            }
-        )
-
-        result = {
-            :main => {
-                :file => "/other",
-                :_meta => {
-                    :file => {
-                        :owner => "you",
-                        :group => "you",
-                        :mode => "644"
-                    }
-                }
-            }
-        }
-
-        @config.expects(:parse_file).returns(result)
-
-        assert_nothing_raised("Could not handle file options") do
-            @config.parse("/whatever")
-        end
-
-        # Get the actual object, so we can verify metadata
-        file = @config.element(:file)
-
-        assert_equal("/other", @config[:file], "Did not get correct value")
-        assert_equal("you", file.owner, "Did not pass on user")
-        assert_equal("you", file.group, "Did not pass on group")
-        assert_equal("644", file.mode, "Did not pass on mode")
-    end
-
     def test_arghandling
         c = mkconfig
 
@@ -548,91 +323,6 @@ yay = /a/path
         assert_equal(should, result, "Add args functional test failed")
     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()
-        file = "$mydir/myfile"
-        realfile = File.join(dir, "myfile")
-        otherfile = File.join(dir, "otherfile")
-        section = "testing"
-        assert_nothing_raised {
-            @config.setdefaults(section,
-                :mydir => [dir, "A dir arg"],
-                :otherfile => {
-                    :default => "$mydir/otherfile",
-                    :create => true,
-                    :desc => "A file arg"
-                },
-                :myfile => [file, "A file arg"]
-            )
-        }
-
-        assert_nothing_raised("Could not use a section") {
-            @config.use(section)
-        }
-
-        assert_nothing_raised("Could not reuse a 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")
-        assert(!FileTest.exists?(realfile), "Created file")
-    end
-
-    def test_setdefaultsarray
-        c = mkconfig
-
-        assert_nothing_raised {
-            @config.setdefaults("yay",
-                :a => [false, "some value"],
-                :b => ["/my/file", "a file"]
-            )
-        }
-
-        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 {
-            @config.setdefaults("yay",
-                :a => {:default => false, :desc => "some value"},
-                :b => {:default => "/my/file", :desc => "a file"}
-            )
-        }
-
-        assert_equal(false, @config[:a], "Values are not equal")
-        assert_equal("/my/file", @config[:b], "Values are not equal")
-    end
-
-    def test_notmanagingdev
-        c = mkconfig
-        path = "/dev/testing"
-        @config.setdefaults(:test,
-            :file => {
-                :default => path,
-                :mode => 0640,
-                :desc => 'yay'
-            }
-        )
-
-        config = @config.to_configuration
-
-        assert(! config.resource(:file, "/dev/testing"), "Created dev file")
-    end
-
     def test_groupsetting
         cfile = tempfile()
 
@@ -645,10 +335,10 @@ yay = /a/path
         end
 
         config = mkconfig
-        config.setdefaults(Puppet[:name], :group => ["puppet", "a group"])
+        config.setdefaults(Puppet[:name], :group => ["puppet", "a group"], :config => [cfile, "eh"])
 
         assert_nothing_raised {
-            config.parse(cfile)
+            config.parse
         }
 
         assert_equal(group, config[:group], "Group did not take")
@@ -658,7 +348,7 @@ yay = /a/path
     # already stored in a config
     def test_writingfiles
         File.umask(0022)
-      
+
         path = tempfile()
         mode = 0644
 
@@ -684,12 +374,12 @@ yay = /a/path
 
         assert_equal(mode, filemode(path), "Modes are not equal")
 
-        # OS X is broken in how it chgrps files 
+        # OS X is broken in how it chgrps files
         if Puppet::Util::SUIDManager.uid == 0
             assert_equal(user.uid, File.stat(path).uid, "UIDS are not equal")
 
             case Facter["operatingsystem"].value
-            when /BSD/, "Darwin": # nothing
+            when /BSD/, "Darwin" # nothing
             else
                 assert_equal(group.gid, File.stat(path).gid, "GIDS are not equal")
             end
@@ -698,7 +388,7 @@ yay = /a/path
 
     def test_mkdir
         File.umask(0022)
-        
+
         path = tempfile()
         mode = 0755
 
@@ -723,12 +413,12 @@ yay = /a/path
         assert_equal(mode, filemode(path), "Modes are not equal")
 
 
-        # OS X and *BSD is broken in how it chgrps files 
+        # OS X and *BSD is broken in how it chgrps files
         if Puppet::Util::SUIDManager.uid == 0
             assert_equal(user.uid, File.stat(path).uid, "UIDS are not equal")
 
             case Facter["operatingsystem"].value
-            when /BSD/, "Darwin": # nothing
+            when /BSD/, "Darwin" # nothing
             else
                 assert_equal(group.gid, File.stat(path).gid, "GIDS are not equal")
             end
@@ -758,7 +448,7 @@ yay = /a/path
 
     def test_configs_replace_in_url
         config = mkconfig
-        
+
         config.setdefaults(:mysection, :name => ["yayness", "yay"])
         config.setdefaults(:mysection, :url => ["http://$name/rahness", "yay"])
 
@@ -772,11 +462,9 @@ yay = /a/path
     end
 
     def test_correct_type_assumptions
-        config = mkconfig
-
-        file = Puppet::Util::Settings::CFile
-        element = Puppet::Util::Settings::CElement
-        bool = Puppet::Util::Settings::CBoolean
+        file = Puppet::Util::Settings::FileSetting
+        element = Puppet::Util::Settings::Setting
+        bool = Puppet::Util::Settings::BooleanSetting
 
         # We have to keep these ordered, unfortunately.
         [
@@ -789,56 +477,19 @@ yay = /a/path
             ["$server/yayness", file],
             ["$server/yayness.conf", file]
         ].each do |ary|
+            config = mkconfig
             value, type = ary
+            name = value.to_s + "_setting"
             assert_nothing_raised {
-                config.setdefaults(:yayness, value => { :default => value, :desc => name.to_s})
+                config.setdefaults(:yayness, name => { :default => value, :desc => name.to_s})
             }
-            elem = config.element(value)
+            elem = config.element(name)
 
             assert_instance_of(type, elem,
                 "%s got created as wrong type" % value.inspect)
         end
     end
 
-    # Make sure we correctly reparse our config files but don't lose CLI values.
-    def test_reparse
-        Puppet[:filetimeout] = 0
-
-        config = mkconfig()
-        config.setdefaults(:mysection, :default => ["default", "yay"])
-        config.setdefaults(:mysection, :clichange => ["clichange", "yay"])
-        config.setdefaults(:mysection, :filechange => ["filechange", "yay"])
-
-        config.stubs(:read_file).returns(%{[main]\nfilechange = filevalue\n})
-        file = mock 'file'
-        file.stubs(:changed?).returns(true)
-
-        assert_nothing_raised {
-            config.parse(file)
-        }
-
-        # Set another "from the cli"
-        assert_nothing_raised {
-            config.handlearg("clichange", "clivalue")
-        }
-
-        # And leave the other unset
-        assert_equal("default", config[:default])
-        assert_equal("filevalue", config[:filechange], "Did not get value from file")
-        assert_equal("clivalue", config[:clichange])
-
-        # Now reparse
-        config.stubs(:read_file).returns(%{[main]\nfilechange = newvalue\n})
-        file = mock 'file'
-        file.stubs(:changed?).returns(true)
-        config.parse(file)
-
-        # And check all of the values
-        assert_equal("default", config[:default])
-        assert_equal("clivalue", config[:clichange])
-        assert_equal("newvalue", config[:filechange])
-    end
-
     def test_parse_removes_quotes
         config = mkconfig()
         config.setdefaults(:mysection, :singleq => ["single", "yay"])
@@ -857,8 +508,10 @@ yay = /a/path
 }
         }
 
+        config.setdefaults(:mysection, :config => [file, "eh"])
+
         assert_nothing_raised {
-            config.parse(file)
+            config.parse
         }
 
         %w{singleq doubleq none}.each do |p|
@@ -867,49 +520,6 @@ yay = /a/path
         assert_equal('mid"quote', config["middle"], "middle did not match")
     end
 
-    def test_timer
-        Puppet[:filetimeout] = 0.1
-        origpath = tempfile()
-        config = mkconfig()
-        config.setdefaults(:mysection, :paramdir => [tempfile(), "yay"])
-
-        file = tempfile()
-        # Set one parameter in the file
-        File.open(file, "w") { |f|
-            f.puts %{[main]\n
-    paramdir = #{origpath}
-}
-        }
-
-        assert_nothing_raised {
-            config.parse(file)
-            config.use(:mysection)
-        }
-
-        assert(FileTest.directory?(origpath), "dir did not get created")
-
-        # Now start the timer
-        assert_nothing_raised {
-            EventLoop.current.monitor_timer config.timer
-        }
-
-        newpath = tempfile()
-
-        File.open(file, "w") { |f|
-            f.puts %{[main]\n
-    paramdir = #{newpath}
-}
-        }
-        config.file.send("tstamp=".intern, Time.now - 50)
-        sleep 1
-
-        assert_equal(newpath, config["paramdir"],
-                    "File did not get reparsed from timer")
-        assert(FileTest.directory?(newpath), "new dir did not get created")
-
-
-    end
-
     # Test that config parameters correctly call passed-in blocks when the value
     # is set.
     def test_paramblocks
@@ -981,7 +591,7 @@ yay = /a/path
         # Now enable it so they'll be added
         config[:mkusers] = true
 
-        comp = config.to_configuration
+        comp = config.to_catalog
 
         comp.vertices.find_all { |r| r.class.name == :user }.each do |u|
             assert(u.name != "root", "Tried to manage root user")
@@ -1000,16 +610,16 @@ yay = /a/path
 #        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) }
+
+        config.setdefaults(:yay, :config => [file, "eh"], :rah => ["testing", "a desc"])
+
+        assert_nothing_raised { config.parse }
         assert_equal("something", config[:rah], "did not remove trailing whitespace in parsing")
     end
 
@@ -1017,7 +627,6 @@ yay = /a/path
     def test_parsing_unknown_variables
         logstore()
         config = mkconfig()
-        config.setdefaults(:mysection, :one => ["yay", "yay"])
         file = tempfile()
         File.open(file, "w") { |f|
             f.puts %{[main]\n
@@ -1026,8 +635,10 @@ yay = /a/path
             }
         }
 
+        config.setdefaults(:mysection, :config => [file, "eh"], :one => ["yay", "yay"])
+
         assert_nothing_raised("Unknown parameter threw an exception") do
-            config.parse(file)
+            config.parse
         end
     end
 
@@ -1058,12 +669,12 @@ yay = /a/path
     def test_celement_short_name
         element = nil
         assert_nothing_raised("Could not create celement") do
-            element = CElement.new :short => "n", :desc => "anything", :settings => Puppet::Util::Settings.new
+            element = Setting.new :short => "n", :desc => "anything", :settings => Puppet::Util::Settings.new
         end
         assert_equal("n", element.short, "Short value is not retained")
 
         assert_raise(ArgumentError,"Allowed multicharactered short names.") do
-            element = CElement.new :short => "no", :desc => "anything", :settings => Puppet::Util::Settings.new
+            element = Setting.new :short => "no", :desc => "anything", :settings => Puppet::Util::Settings.new
         end
     end
 
@@ -1088,13 +699,13 @@ yay = /a/path
 
     # Tell getopt which arguments are valid
     def test_get_getopt_args
-        element = CElement.new :name => "foo", :desc => "anything", :settings => Puppet::Util::Settings.new
+        element = Setting.new :name => "foo", :desc => "anything", :settings => Puppet::Util::Settings.new
         assert_equal([["--foo", GetoptLong::REQUIRED_ARGUMENT]], element.getopt_args, "Did not produce appropriate getopt args")
-        
+
         element.short = "n"
         assert_equal([["--foo", "-n", GetoptLong::REQUIRED_ARGUMENT]], element.getopt_args, "Did not produce appropriate getopt args")
 
-        element = CBoolean.new :name => "foo", :desc => "anything", :settings => Puppet::Util::Settings.new
+        element = BooleanSetting.new :name => "foo", :desc => "anything", :settings => Puppet::Util::Settings.new
         assert_equal([["--foo", GetoptLong::NO_ARGUMENT], ["--no-foo", GetoptLong::NO_ARGUMENT]],
                      element.getopt_args, "Did not produce appropriate getopt args")