puppet 0.24.9 → 0.25.0

data/spec/unit/util/package.rb

@@ -14,8 +14,8 @@ describe Puppet::Util::Package, " versioncmp" do
         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 = ary.sort { |a, b| Puppet::Util::Package.versioncmp(a,b) }
-        
+
         newary.should == ["0002", "1", "1.06", "1.1-3", "1.1-4", "1.1-5", "1.1.6", "1.1.a", "1.1a", "1.2", "1.5", "2.3", "2.3.0", "2.3.1", "2.3a.1", "2.4", "2.4", "2.4b", "2.40.2", "3.0", "3.1"]
     end
-    
+
 end

data/spec/unit/util/queue.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/util/queue'
+require 'spec/mocks'
+
+def make_test_client_class(n)
+    c = Class.new do
+        class <<self
+            attr_accessor :name
+            def to_s
+                name
+            end
+        end
+    end
+    c.name = n
+    c
+end
+
+mod = Puppet::Util::Queue
+client_classes = { :default => make_test_client_class('Bogus::Default'), :setup => make_test_client_class('Bogus::Setup') }
+mod.register_queue_type(client_classes[:default], :default)
+mod.register_queue_type(client_classes[:setup], :setup)
+
+describe Puppet::Util::Queue do
+    before :each do
+        @class = Class.new do
+            extend mod
+        end
+    end
+
+    context 'when determining a type name from a class' do
+        it 'should handle a simple one-word class name' do
+            mod.queue_type_from_class(make_test_client_class('Foo')).should == :foo
+        end
+
+        it 'should handle a simple two-word class name' do
+            mod.queue_type_from_class(make_test_client_class('FooBar')).should == :foo_bar
+        end
+
+        it 'should handle a two-part class name with one terminating word' do
+            mod.queue_type_from_class(make_test_client_class('Foo::Bar')).should == :bar
+        end
+
+        it 'should handle a two-part class name with two terminating words' do
+            mod.queue_type_from_class(make_test_client_class('Foo::BarBah')).should == :bar_bah
+        end
+    end
+
+    context 'when registering a queue client class' do
+        c = make_test_client_class('Foo::Bogus')
+        it 'uses the proper default name logic when type is unspecified' do
+            mod.register_queue_type(c)
+            mod.queue_type_to_class(:bogus).should == c
+        end
+
+        it 'uses an explicit type name when provided' do
+            mod.register_queue_type(c, :aardvark)
+            mod.queue_type_to_class(:aardvark).should == c
+        end
+
+        it 'throws an exception when type names conflict' do
+            mod.register_queue_type( make_test_client_class('Conflict') )
+            lambda { mod.register_queue_type( c, :conflict) }.should raise_error
+        end
+
+        it 'handle multiple, non-conflicting registrations' do
+            a = make_test_client_class('TestA')
+            b = make_test_client_class('TestB')
+            mod.register_queue_type(a)
+            mod.register_queue_type(b)
+            mod.queue_type_to_class(:test_a).should == a
+            mod.queue_type_to_class(:test_b).should == b
+        end
+
+        it 'throws an exception when type name is unknown' do
+            lambda { mod.queue_type_to_class(:nope) }.should raise_error
+        end
+    end
+
+    context 'when determining client type' do
+        it 'returns client class based on the :queue_type setting' do
+            Puppet.settings.expects(:value).with(:queue_type).returns(:myqueue)
+            Puppet::Util::Queue.expects(:queue_type_to_class).with(:myqueue).returns "eh"
+            @class.client_class.should == "eh"
+        end
+    end
+end

data/spec/unit/util/queue/stomp.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/util/queue'
+
+describe Puppet::Util::Queue do
+    confine "Missing Stomp" => Puppet.features.stomp?
+
+    it 'should load :stomp client appropriately' do
+        Puppet.settings.stubs(:value).returns 'faux_queue_source'
+        Puppet::Util::Queue.queue_type_to_class(:stomp).name.should == 'Puppet::Util::Queue::Stomp'
+    end
+end
+
+describe 'Puppet::Util::Queue::Stomp' do
+    confine "Missing Stomp" => Puppet.features.stomp?
+
+    before do
+        # So we make sure we never create a real client instance.
+        # Otherwise we'll try to connect, and that's bad.
+        Stomp::Client.stubs(:new).returns stub("client")
+    end
+
+    it 'should be registered with Puppet::Util::Queue as :stomp type' do
+        Puppet::Util::Queue.queue_type_to_class(:stomp).should == Puppet::Util::Queue::Stomp
+    end
+
+    describe "when initializing" do
+        it "should create a Stomp client instance" do
+            Stomp::Client.expects(:new).returns stub("stomp_client")
+            Puppet::Util::Queue::Stomp.new
+        end
+
+        it "should provide helpful failures when the queue source is not a valid source" do
+            # Stub rather than expect, so we can include the source in the error
+            Puppet.settings.stubs(:value).with(:queue_source).returns "-----"
+
+            lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
+        end
+
+        it "should fail unless the queue source is a stomp URL" do
+            # Stub rather than expect, so we can include the source in the error
+            Puppet.settings.stubs(:value).with(:queue_source).returns "http://foo/bar"
+
+            lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
+        end
+
+        it "should fail somewhat helpfully if the Stomp client cannot be created" do
+            Stomp::Client.expects(:new).raises RuntimeError
+            lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
+        end
+
+        list = %w{user password host port}
+        {"user" => "myuser", "password" => "mypass", "host" => "foohost", "port" => 42}.each do |name, value|
+            it "should use the #{name} from the queue source as the queueing #{name}" do
+                Puppet.settings.expects(:value).with(:queue_source).returns "stomp://myuser:mypass@foohost:42/"
+
+                Stomp::Client.expects(:new).with { |*args| args[list.index(name)] == value }
+                Puppet::Util::Queue::Stomp.new
+            end
+        end
+
+        it "should create a reliable client instance" do
+            Puppet.settings.expects(:value).with(:queue_source).returns "stomp://myuser@foohost:42/"
+
+            Stomp::Client.expects(:new).with { |*args| args[4] == true }
+            Puppet::Util::Queue::Stomp.new
+        end
+    end
+
+    describe "when sending a message" do
+        before do
+            @client = stub 'client'
+            Stomp::Client.stubs(:new).returns @client
+            @queue = Puppet::Util::Queue::Stomp.new
+        end
+
+        it "should send it to the queue client instance" do
+            @client.expects(:send).with { |queue, msg, options| msg == "Smite!" }
+            @queue.send_message('fooqueue', 'Smite!')
+        end
+
+        it "should send it to the transformed queue name" do
+            @client.expects(:send).with { |queue, msg, options| queue == "/queue/fooqueue" }
+            @queue.send_message('fooqueue', 'Smite!')
+        end
+
+        it "should send it as a persistent message" do
+            @client.expects(:send).with { |queue, msg, options| options[:persistent] == true }
+            @queue.send_message('fooqueue', 'Smite!')
+        end
+    end
+
+    describe "when subscribing to a queue" do
+        before do
+            @client = stub 'client', :acknowledge => true
+            Stomp::Client.stubs(:new).returns @client
+            @queue = Puppet::Util::Queue::Stomp.new
+        end
+
+        it "should subscribe via the queue client instance" do
+            @client.expects(:subscribe)
+            @queue.subscribe('fooqueue')
+        end
+
+        it "should subscribe to the transformed queue name" do
+            @client.expects(:subscribe).with { |queue, options| queue == "/queue/fooqueue" }
+            @queue.subscribe('fooqueue')
+        end
+
+        it "should specify that its messages should be acknowledged" do
+            @client.expects(:subscribe).with { |queue, options| options[:ack] == :client }
+            @queue.subscribe('fooqueue')
+        end
+
+        it "should yield the body of any received message" do
+            message = mock 'message'
+            message.expects(:body).returns "mybody"
+
+            @client.expects(:subscribe).yields(message)
+
+            body = nil
+            @queue.subscribe('fooqueue') { |b| body = b }
+            body.should == "mybody"
+        end
+
+        it "should acknowledge all successfully processed messages" do
+            message = stub 'message', :body => "mybode"
+
+            @client.stubs(:subscribe).yields(message)
+            @client.expects(:acknowledge).with(message)
+
+            @queue.subscribe('fooqueue') { |b| "eh" }
+        end
+    end
+
+    it 'should transform the simple queue name to "/queue/<queue_name>"' do
+        Puppet::Util::Queue::Stomp.new.stompify_target('blah').should == '/queue/blah'
+    end
+end

data/spec/unit/util/reference_serializer.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/util/rails/reference_serializer'
+
+class SerializeTester
+    include Puppet::Util::ReferenceSerializer
+end
+
+describe Puppet::Util::ReferenceSerializer do
+    before do
+        @tester = SerializeTester.new
+    end
+
+    describe "when serializing" do
+        it "should yaml-dump resource references" do
+            ref = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/foo")
+            @tester.serialize_value(ref).should =~ /^---/
+        end
+
+        it "should convert the boolean 'true' into the string 'true'" do
+            @tester.serialize_value(true).should == "true"
+        end
+
+        it "should convert the boolean 'false' into the string 'false'" do
+            @tester.serialize_value(false).should == "false"
+        end
+
+        it "should return all other values" do
+            @tester.serialize_value("foo").should == "foo"
+        end
+    end
+
+    describe "when unserializing" do
+        it "should yaml-load values that look like yaml" do
+            yaml = YAML.dump(%w{a b c})
+            @tester.unserialize_value(yaml).should == %w{a b c}
+        end
+
+        it "should convert the string 'true' into the boolean 'true'" do
+            @tester.unserialize_value("true").should == true
+        end
+
+        it "should convert the string 'false' into the boolean 'false'" do
+            @tester.unserialize_value("false").should == false
+        end
+
+        it "should return all other values" do
+            @tester.unserialize_value("foo").should == "foo"
+        end
+    end
+end

data/spec/unit/util/selinux.rb

@@ -31,7 +31,9 @@ describe Puppet::Util::SELinux do
 
     describe "filesystem detection" do
         before :each do
-            File.expects(:read).with("/proc/mounts").returns "rootfs / rootfs rw 0 0\n/dev/root / ext3 rw,relatime,errors=continue,user_xattr,acl,data=ordered 0 0\n/dev /dev tmpfs rw,relatime,mode=755 0 0\n/proc /proc proc rw,relatime 0 0\n/sys /sys sysfs rw,relatime 0 0\n192.168.1.1:/var/export /mnt/nfs nfs rw,relatime,vers=3,rsize=32768,wsize=32768,namlen=255,hard,nointr,proto=tcp,timeo=600,retrans=2,sec=sys,mountaddr=192.168.1.1,mountvers=3,mountproto=udp,addr=192.168.1.1 0 0\n"
+            fh = stub 'fh', :close => nil
+            File.stubs(:open).with("/proc/mounts").returns fh
+            fh.expects(:read_nonblock).times(2).returns("rootfs / rootfs rw 0 0\n/dev/root / ext3 rw,relatime,errors=continue,user_xattr,acl,data=ordered 0 0\n/dev /dev tmpfs rw,relatime,mode=755 0 0\n/proc /proc proc rw,relatime 0 0\n/sys /sys sysfs rw,relatime 0 0\n192.168.1.1:/var/export /mnt/nfs nfs rw,relatime,vers=3,rsize=32768,wsize=32768,namlen=255,hard,nointr,proto=tcp,timeo=600,retrans=2,sec=sys,mountaddr=192.168.1.1,mountvers=3,mountproto=udp,addr=192.168.1.1 0 0\n").then.raises EOFError
         end
 
         it "should parse the contents of /proc/mounts" do
@@ -46,7 +48,7 @@ describe Puppet::Util::SELinux do
         it "should match a path on / to ext3" do
             find_fs('/etc/puppet/testfile').should == "ext3"
         end
-        
+
         it "should match a path on /mnt/nfs to nfs" do
             find_fs('/mnt/nfs/testfile/foobar').should == "nfs"
         end
@@ -109,7 +111,7 @@ describe Puppet::Util::SELinux do
             self.expects(:find_fs).with("/foo").returns "nfs"
             get_selinux_default_context("/foo").should be_nil
         end
-            
+
     end
 
     describe "parse_selinux_context" do

data/spec/unit/util/settings.rb

@@ -2,7 +2,7 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Puppet::Util::Settings do 
+describe Puppet::Util::Settings do
     describe "when specifying defaults" do
         before do
             @settings = Puppet::Util::Settings.new
@@ -39,13 +39,22 @@ describe Puppet::Util::Settings do
         end
 
         it "should support specifying owner, group, and mode when specifying files" do
-            @settings.setdefaults(:section, :myvalue => {:default => "/some/file", :owner => "blah", :mode => "boo", :group => "yay", :desc => "whatever"})
+            @settings.setdefaults(:section, :myvalue => {:default => "/some/file", :owner => "service", :mode => "boo", :group => "service", :desc => "whatever"})
         end
 
         it "should support specifying a short name" do
             @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"})
         end
 
+        it "should support specifying the setting type" do
+            @settings.setdefaults(:section, :myvalue => {:default => "/w", :desc => "b", :type => :setting})
+            @settings.setting(:myvalue).should be_instance_of(Puppet::Util::Settings::Setting)
+        end
+
+        it "should fail if an invalid setting type is specified" do
+            lambda { @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :type => :foo}) }.should raise_error(ArgumentError)
+        end
+
         it "should fail when short names conflict" do
             @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"})
             lambda { @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) }.should raise_error(ArgumentError)
@@ -70,17 +79,38 @@ describe Puppet::Util::Settings do
         end
 
         it "should support a getopt-specific mechanism for turning booleans off" do
-            @settings.handlearg("--no-bool")
+            @settings.handlearg("--no-bool", "")
             @settings[:bool].should == false
         end
 
         it "should support a getopt-specific mechanism for turning booleans on" do
+            # Turn it off first
+            @settings[:bool] = false
+            @settings.handlearg("--bool", "")
+            @settings[:bool].should == true
+        end
+
+        it "should consider a cli setting with no argument to be a boolean" do
             # Turn it off first
             @settings[:bool] = false
             @settings.handlearg("--bool")
             @settings[:bool].should == true
         end
 
+        it "should consider a cli setting with an empty string as an argument to be a boolean" do
+            # Turn it off first
+            @settings[:bool] = false
+            @settings.handlearg("--bool", "")
+            @settings[:bool].should == true
+        end
+
+        it "should consider a cli setting with a boolean as an argument to be a boolean" do
+            # Turn it off first
+            @settings[:bool] = false
+            @settings.handlearg("--bool", true)
+            @settings[:bool].should == true
+        end
+
         it "should clear the cache when setting getopt-specific values" do
             @settings.setdefaults :mysection, :one => ["whah", "yay"], :two => ["$one yay", "bah"]
             @settings[:two].should == "whah yay"
@@ -90,10 +120,15 @@ describe Puppet::Util::Settings do
 
         it "should not clear other values when setting getopt-specific values" do
             @settings[:myval] = "yay"
-            @settings.handlearg("--no-bool")
+            @settings.handlearg("--no-bool", "")
             @settings[:myval].should == "yay"
         end
 
+        it "should clear the list of used sections" do
+            @settings.expects(:clearused)
+            @settings[:myval] = "yay"
+        end
+
         it "should call passed blocks when values are set" do
             values = []
             @settings.setdefaults(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
@@ -103,6 +138,16 @@ describe Puppet::Util::Settings do
             values.should == %w{something}
         end
 
+        it "should call passed blocks when values are set via the command line" do
+            values = []
+            @settings.setdefaults(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
+            values.should == []
+
+            @settings.handlearg("--hooker", "yay")
+
+            values.should == %w{yay}
+        end
+
         it "should provide an option to call passed blocks during definition" do
             values = []
             @settings.setdefaults(:section, :hooker => {:default => "yay", :desc => "boo", :call_on_define => true, :hook => lambda { |v| values << v }})
@@ -116,7 +161,7 @@ describe Puppet::Util::Settings do
             values.should == %w{test/yay}
         end
 
-        it "should munge values using the element-specific methods" do
+        it "should munge values using the setting-specific methods" do
             @settings[:bool] = "false"
             @settings[:bool].should == false
         end
@@ -126,12 +171,18 @@ describe Puppet::Util::Settings do
             @settings[:myval] = "memarg"
             @settings[:myval].should == "cliarg"
         end
+
+        it "should clear the list of environments" do
+            Puppet::Node::Environment.expects(:clear).at_least(1)
+            @settings[:myval] = "memarg"
+        end
     end
 
     describe "when returning values" do
         before do
             @settings = Puppet::Util::Settings.new
-            @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"], :four => ["$two $three FOUR", "d"]
+            @settings.setdefaults :section, :config => ["/my/file", "eh"], :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"], :four => ["$two $three FOUR", "d"]
+            FileTest.stubs(:exist?).returns true
         end
 
         it "should provide a mechanism for returning set values" do
@@ -168,11 +219,8 @@ describe Puppet::Util::Settings do
 
         it "should not cache values such that information from one environment is returned for another environment" do
             text = "[env1]\none = oneval\n[env2]\none = twoval\n"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
 
             @settings.value(:one, "env1").should == "oneval"
             @settings.value(:one, "env2").should == "twoval"
@@ -190,8 +238,10 @@ describe Puppet::Util::Settings do
         before do
             @settings = Puppet::Util::Settings.new
             @settings.setdefaults :section,
+                :config => ["/my/file", "a"],
                 :one => ["ONE", "a"],
                 :name => ["myname", "w"]
+            FileTest.stubs(:exist?).returns true
         end
 
         it "should return default values if no values have been set" do
@@ -200,12 +250,9 @@ describe Puppet::Util::Settings do
 
         it "should return values set on the cli before values set in the configuration file" do
             text = "[main]\none = fileval\n"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:parse_file).returns(text)
+            @settings.stubs(:read_file).returns(text)
             @settings.handlearg("--one", "clival")
-            @settings.parse(file)
+            @settings.parse
 
             @settings[:one].should == "clival"
         end
@@ -218,11 +265,8 @@ describe Puppet::Util::Settings do
 
         it "should return values set in the executable-specific section before values set in the main section" do
             text = "[main]\none = mainval\n[myname]\none = nameval\n"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
 
             @settings[:one].should == "nameval"
         end
@@ -230,22 +274,15 @@ describe Puppet::Util::Settings do
         it "should not return values outside of its search path" do
             text = "[other]\none = oval\n"
             file = "/some/file"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
             @settings[:one].should == "ONE"
         end
 
         it "should return values in a specified environment" do
             text = "[env]\none = envval\n"
-            file = "/some/file"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
             @settings.value(:one, "env").should == "envval"
         end
 
@@ -257,12 +294,8 @@ describe Puppet::Util::Settings do
 
         it "should return values in a specified environment before values in the main or name sections" do
             text = "[env]\none = envval\n[main]\none = mainval\n[myname]\none = nameval\n"
-            file = "/some/file"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
             @settings.value(:one, "env").should == "envval"
         end
     end
@@ -270,30 +303,55 @@ describe Puppet::Util::Settings do
     describe "when parsing its configuration" do
         before do
             @settings = Puppet::Util::Settings.new
-            @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"]
+            @settings.stubs(:service_user_available?).returns true
+            @file = "/some/file"
+            @settings.setdefaults :section, :user => ["suser", "doc"], :group => ["sgroup", "doc"]
+            @settings.setdefaults :section, :config => ["/some/file", "eh"], :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"]
+            FileTest.stubs(:exist?).returns true
+        end
+
+        it "should use its current ':config' value for the file to parse" do
+            @settings[:config] = "/my/file"
+
+            File.expects(:read).with("/my/file").returns("[main]")
+
+            @settings.parse
+        end
+
+        it "should fail if no configuration setting is defined" do
+            @settings = Puppet::Util::Settings.new
+            lambda { @settings.parse }.should raise_error(RuntimeError)
+        end
+
+        it "should not try to parse non-existent files" do
+            FileTest.expects(:exist?).with("/some/file").returns false
+
+            File.expects(:read).with("/some/file").never
+
+            @settings.parse
+        end
+
+        it "should set a timer that triggers reparsing, even if the file does not exist" do
+            FileTest.expects(:exist?).returns false
+            @settings.expects(:set_filetimeout_timer)
+
+            @settings.parse
         end
 
         it "should return values set in the configuration file" do
             text = "[main]
             one = fileval
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             @settings[:one].should == "fileval"
         end
 
         #484 - this should probably be in the regression area
         it "should not throw an exception on unknown parameters" do
             text = "[main]\nnosuchparam = mval\n"
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            lambda { @settings.parse(file) }.should_not raise_error
-        end
-
-        it "should support an old parse method when per-executable configuration files still exist" do
-            # I'm not going to bother testing this method.
-            @settings.should respond_to(:old_parse)
+            @settings.expects(:read_file).returns(text)
+            lambda { @settings.parse }.should_not raise_error
         end
 
         it "should convert booleans in the configuration file into Ruby booleans" do
@@ -301,9 +359,8 @@ describe Puppet::Util::Settings do
             one = true
             two = false
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             @settings[:one].should == true
             @settings[:two].should == false
         end
@@ -312,9 +369,8 @@ describe Puppet::Util::Settings do
             text = "[main]
             one = 65
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             @settings[:one].should == 65
         end
 
@@ -322,26 +378,25 @@ describe Puppet::Util::Settings do
             @settings.setdefaults :section, :myfile => ["/myfile", "a"]
 
             text = "[main]
-            myfile = /other/file {owner = luke, group = luke, mode = 644}
+            myfile = /other/file {owner = service, group = service, mode = 644}
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             @settings[:myfile].should == "/other/file"
-            @settings.metadata(:myfile).should == {:owner => "luke", :group => "luke", :mode => "644"}
+            @settings.metadata(:myfile).should == {:owner => "suser", :group => "sgroup", :mode => "644"}
         end
 
         it "should support specifying a single piece of metadata (owner, group, or mode) in the configuration file" do
             @settings.setdefaults :section, :myfile => ["/myfile", "a"]
 
             text = "[main]
-            myfile = /other/file {owner = luke}
+            myfile = /other/file {owner = service}
             "
             file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             @settings[:myfile].should == "/other/file"
-            @settings.metadata(:myfile).should == {:owner => "luke"}
+            @settings.metadata(:myfile).should == {:owner => "suser"}
         end
 
         it "should call hooks associated with values set in the configuration file" do
@@ -351,9 +406,8 @@ describe Puppet::Util::Settings do
             text = "[main]
             mysetting = setval
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             values.should == ["setval"]
         end
 
@@ -366,9 +420,8 @@ describe Puppet::Util::Settings do
             [puppet]
             mysetting = other
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             values.should == ["setval"]
         end
 
@@ -383,9 +436,8 @@ describe Puppet::Util::Settings do
             [yay]
             mysetting = other
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             values.should == ["other"]
         end
 
@@ -397,9 +449,8 @@ describe Puppet::Util::Settings do
             text = "[main]
             mysetting = $base/setval
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             values.should == ["yay/setval"]
         end
 
@@ -410,7 +461,7 @@ describe Puppet::Util::Settings do
             myarg =
             "
             @settings.stubs(:read_file).returns(text)
-            @settings.parse("/some/file")
+            @settings.parse
             @settings[:myarg].should == ""
         end
     end
@@ -418,7 +469,59 @@ describe Puppet::Util::Settings do
     describe "when reparsing its configuration" do
         before do
             @settings = Puppet::Util::Settings.new
-            @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"]
+            @settings.setdefaults :section, :config => ["/test/file", "a"], :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"]
+            FileTest.stubs(:exist?).returns true
+        end
+
+        it "should use a LoadedFile instance to determine if the file has changed" do
+            file = mock 'file'
+            Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
+
+            file.expects(:changed?)
+
+            @settings.stubs(:parse)
+            @settings.reparse
+        end
+
+        it "should not create the LoadedFile instance and should not parse if the file does not exist" do
+            FileTest.expects(:exist?).with("/test/file").returns false
+            Puppet::Util::LoadedFile.expects(:new).never
+
+            @settings.expects(:parse).never
+
+            @settings.reparse
+        end
+
+        it "should not reparse if the file has not changed" do
+            file = mock 'file'
+            Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
+
+            file.expects(:changed?).returns false
+
+            @settings.expects(:parse).never
+
+            @settings.reparse
+        end
+
+        it "should reparse if the file has changed" do
+            file = stub 'file', :file => "/test/file"
+            Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
+
+            file.expects(:changed?).returns true
+
+            @settings.expects(:parse)
+
+            @settings.reparse
+        end
+
+        it "should use a cached LoadedFile instance" do
+            first = mock 'first'
+            second = mock 'second'
+            Puppet::Util::LoadedFile.expects(:new).times(2).with("/test/file").returns(first).then.returns(second)
+
+            @settings.file.should equal(first)
+            Puppet::Util::Cacher.expire
+            @settings.file.should equal(second)
         end
 
         it "should replace in-memory values with on-file values" do
@@ -432,11 +535,11 @@ describe Puppet::Util::Settings do
 
             # Now replace the value
             text = "[main]\none = disk-replace\n"
-            
+
             # This is kinda ridiculous - the reason it parses twice is that
             # it goes to parse again when we ask for the value, because the
             # mock always says it should get reparsed.
-            @settings.expects(:read_file).with(file).returns(text).times(2)
+            @settings.stubs(:read_file).returns(text)
             @settings.reparse
             @settings[:one].should == "disk-replace"
         end
@@ -445,10 +548,8 @@ describe Puppet::Util::Settings do
             @settings.handlearg("--one", "clival")
 
             text = "[main]\none = on-disk\n"
-            file = mock 'file'
-            file.stubs(:file).returns("/test/file")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
 
             @settings[:one].should == "clival"
         end
@@ -456,17 +557,14 @@ describe Puppet::Util::Settings do
         it "should remove in-memory values that are no longer set in the file" do
             # Init the value
             text = "[main]\none = disk-init\n"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/test/file")
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             @settings[:one].should == "disk-init"
 
             # Now replace the value
             text = "[main]\ntwo = disk-replace\n"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             #@settings.reparse
 
             # The originally-overridden value should be replaced with the default
@@ -477,238 +575,219 @@ describe Puppet::Util::Settings do
         end
     end
 
-    describe "when being used to manage the host machine" do
+    it "should provide a method for creating a catalog of resources from its configuration" do
+        Puppet::Util::Settings.new.should respond_to(:to_catalog)
+    end
+
+    describe "when creating a catalog" do
         before do
             @settings = Puppet::Util::Settings.new
-            @settings.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "a"]
-            @settings.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "luke", :group => "johnny", :mode => 0755}
-            @settings.setdefaults :third, :thirddir => ["/thirddir", "b"]
-            @settings.setdefaults :files, :myfile => {:default => "/myfile", :desc => "a", :mode => 0755}
+            @settings.stubs(:service_user_available?).returns true
         end
 
-        after do
-            Puppet::Type.type(:file).clear
-        end
-
-        def stub_transaction
-            @bucket = mock 'bucket'
-            @config = mock 'config', :clear => nil
-            @trans = mock 'transaction'
-
-            @settings.expects(:to_transportable).with(:whatever).returns(@bucket)
-            @bucket.expects(:to_catalog).returns(@config)
-            @config.expects(:apply).yields(@trans)
-            @config.stubs(:host_config=)
+        it "should add all file resources to the catalog if no sections have been specified" do
+            @settings.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "a"]
+            @settings.setdefaults :other, :otherdir => ["/otherdir", "a"]
+            catalog = @settings.to_catalog
+            %w{/maindir /seconddir /otherdir}.each do |path|
+                catalog.resource(:file, path).should be_instance_of(Puppet::Resource)
+            end
         end
 
-        it "should provide a method that writes files with the correct modes" do
-            pending "Not converted from test/unit yet"
+        it "should add only files in the specified sections if section names are provided" do
+            @settings.setdefaults :main, :maindir => ["/maindir", "a"]
+            @settings.setdefaults :other, :otherdir => ["/otherdir", "a"]
+            catalog = @settings.to_catalog(:main)
+            catalog.resource(:file, "/otherdir").should be_nil
+            catalog.resource(:file, "/maindir").should be_instance_of(Puppet::Resource)
         end
 
-        it "should provide a method that creates directories with the correct modes" do
-            Puppet::Util::SUIDManager.expects(:asuser).with("luke", "johnny").yields
-            Dir.expects(:mkdir).with("/otherdir", 0755)
-            @settings.mkdir(:otherdir)
+        it "should not try to add the same file twice" do
+            @settings.setdefaults :main, :maindir => ["/maindir", "a"]
+            @settings.setdefaults :other, :otherdir => ["/maindir", "a"]
+            lambda { @settings.to_catalog }.should_not raise_error
         end
 
-        it "should be able to create needed directories in a single section" do
-            Dir.expects(:mkdir).with("/maindir")
-            Dir.expects(:mkdir).with("/seconddir")
-            @settings.use(:main)
-        end
+        it "should ignore files whose :to_resource method returns nil" do
+            @settings.setdefaults :main, :maindir => ["/maindir", "a"]
+            @settings.setting(:maindir).expects(:to_resource).returns nil
 
-        it "should be able to create needed directories in multiple sections" do
-            Dir.expects(:mkdir).with("/maindir")
-            Dir.expects(:mkdir).with("/seconddir")
-            Dir.expects(:mkdir).with("/thirddir")
-            @settings.use(:main, :third)
+            Puppet::Resource::Catalog.any_instance.expects(:add_resource).never
+            @settings.to_catalog
         end
 
-        it "should provide a method to trigger enforcing of file modes on existing files and directories" do
-            pending "Not converted from test/unit yet"
-        end
+        describe "when adding users and groups to the catalog" do
+            before do
+                Puppet.features.stubs(:root?).returns true
+                @settings.setdefaults :foo, :mkusers => [true, "e"], :user => ["suser", "doc"], :group => ["sgroup", "doc"]
+                @settings.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
-        it "should provide a method to convert the file mode enforcement into a Puppet manifest" do
-            pending "Not converted from test/unit yet"
-        end
+                @catalog = @settings.to_catalog
+            end
 
-        it "should create files when configured to do so with the :create parameter"
-
-        it "should provide a method to convert the file mode enforcement into transportable resources" do
-            # Make it think we're root so it tries to manage user and group.
-            Puppet.features.stubs(:root?).returns(true)
-            File.stubs(:exist?).with("/myfile").returns(true)
-            trans = nil
-            trans = @settings.to_transportable
-            resources = []
-            trans.delve { |obj| resources << obj if obj.is_a? Puppet::TransObject }
-            %w{/maindir /seconddir /otherdir /myfile}.each do |path|
-                obj = resources.find { |r| r.type == "file" and r.name == path }
-                if path.include?("dir")
-                    obj[:ensure].should == :directory
-                else
-                    # Do not create the file, just manage mode
-                    obj[:ensure].should be_nil
-                end
-                obj.should be_instance_of(Puppet::TransObject)
-                case path
-                when "/otherdir":
-                    obj[:owner].should == "luke"
-                    obj[:group].should == "johnny"
-                    obj[:mode].should == 0755
-                when "/myfile":
-                    obj[:mode].should == 0755
-                end
+            it "should add each specified user and group to the catalog if :mkusers is a valid setting, is enabled, and we're running as root" do
+                @catalog.resource(:user, "suser").should be_instance_of(Puppet::Resource)
+                @catalog.resource(:group, "sgroup").should be_instance_of(Puppet::Resource)
             end
-        end
 
-        it "should not try to manage user or group when not running as root" do
-            Puppet.features.stubs(:root?).returns(false)
-            trans = nil
-            trans = @settings.to_transportable(:other)
-            trans.delve do |obj|
-                next unless obj.is_a?(Puppet::TransObject)
-                obj[:owner].should be_nil
-                obj[:group].should be_nil
+            it "should only add users and groups to the catalog from specified sections" do
+                @settings.setdefaults :yay, :yaydir => {:default => "/yaydir", :desc => "a", :owner => "service", :group => "service"}
+                catalog = @settings.to_catalog(:other)
+                catalog.resource(:user, "jane").should be_nil
+                catalog.resource(:group, "billy").should be_nil
             end
-        end
 
-        it "should add needed users and groups to the manifest when asked" do
-            # This is how we enable user/group management
-            @settings.setdefaults :main, :mkusers => [true, "w"]
-            Puppet.features.stubs(:root?).returns(false)
-            trans = nil
-            trans = @settings.to_transportable(:other)
-            resources = []
-            trans.delve { |obj| resources << obj if obj.is_a? Puppet::TransObject and obj.type != "file" }
+            it "should not add users or groups to the catalog if :mkusers not running as root" do
+                Puppet.features.stubs(:root?).returns false
 
-            user = resources.find { |r| r.type == "user" }
-            user.should be_instance_of(Puppet::TransObject)
-            user.name.should == "luke"
-            user[:ensure].should == :present
+                catalog = @settings.to_catalog
+                catalog.resource(:user, "suser").should be_nil
+                catalog.resource(:group, "sgroup").should be_nil
+            end
 
-            # This should maybe be a separate test, but...
-            group = resources.find { |r| r.type == "group" }
-            group.should be_instance_of(Puppet::TransObject)
-            group.name.should == "johnny"
-            group[:ensure].should == :present
-        end
+            it "should not add users or groups to the catalog if :mkusers is not a valid setting" do
+                Puppet.features.stubs(:root?).returns true
+                settings = Puppet::Util::Settings.new
+                settings.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
-        it "should ignore tags and schedules when creating files and directories"
+                catalog = settings.to_catalog
+                catalog.resource(:user, "suser").should be_nil
+                catalog.resource(:group, "sgroup").should be_nil
+            end
 
-        it "should apply all resources in debug mode to reduce logging"
+            it "should not add users or groups to the catalog if :mkusers is a valid setting but is disabled" do
+                @settings[:mkusers] = false
 
-        it "should not try to manage absent files" do
-            # Make it think we're root so it tries to manage user and group.
-            Puppet.features.stubs(:root?).returns(true)
-            trans = nil
-            trans = @settings.to_transportable
-            file = nil
-            trans.delve { |obj| file = obj if obj.name == "/myfile" }
-            file.should be_nil
-        end
+                catalog = @settings.to_catalog
+                catalog.resource(:user, "suser").should be_nil
+                catalog.resource(:group, "sgroup").should be_nil
+            end
 
-        it "should not try to manage files in memory" do
-            main = Puppet::Type.type(:file).create(:path => "/maindir")
+            it "should not try to add users or groups to the catalog twice" do
+                @settings.setdefaults :yay, :yaydir => {:default => "/yaydir", :desc => "a", :owner => "service", :group => "service"}
 
-            trans = @settings.to_transportable
+                # This would fail if users/groups were added twice
+                lambda { @settings.to_catalog }.should_not raise_error
+            end
 
-            lambda { trans.to_catalog }.should_not raise_error
-        end
+            it "should set :ensure to :present on each created user and group" do
+                @catalog.resource(:user, "suser")[:ensure].should == :present
+                @catalog.resource(:group, "sgroup")[:ensure].should == :present
+            end
 
-        it "should do nothing if a catalog cannot be created" do
-            bucket = mock 'bucket'
-            catalog = mock 'catalog'
+            it "should set each created user's :gid to the service group" do
+                @settings.to_catalog.resource(:user, "suser")[:gid].should == "sgroup"
+            end
 
-            @settings.expects(:to_transportable).returns bucket
-            bucket.expects(:to_catalog).raises RuntimeError
-            catalog.expects(:apply).never
+            it "should not attempt to manage the root user" do
+                Puppet.features.stubs(:root?).returns true
+                @settings.setdefaults :foo, :foodir => {:default => "/foodir", :desc => "a", :owner => "root", :group => "service"}
 
-            @settings.use(:mysection)
+                @settings.to_catalog.resource(:user, "root").should be_nil
+            end
         end
+    end
 
-        it "should clear the catalog after applying" do
-            bucket = mock 'bucket'
-            catalog = mock 'catalog'
-
-            @settings.expects(:to_transportable).returns bucket
-            bucket.expects(:to_catalog).returns catalog
-            catalog.stubs(:host_config=)
-            catalog.stubs(:apply)
-            catalog.expects(:clear)
-
-            @settings.use(:mysection)
-        end
+    it "should be able to be converted to a manifest" do
+        Puppet::Util::Settings.new.should respond_to(:to_manifest)
+    end
 
-        it "should clear the catalog even if there is an exception during applying" do
-            bucket = mock 'bucket'
-            catalog = mock 'catalog'
+    describe "when being converted to a manifest" do
+        it "should produce a string with the code for each resource joined by two carriage returns" do
+            @settings = Puppet::Util::Settings.new
+            @settings.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "a"]
 
-            @settings.expects(:to_transportable).returns bucket
-            bucket.expects(:to_catalog).returns catalog
-            catalog.stubs(:host_config=)
-            catalog.expects(:apply).raises(ArgumentError)
-            catalog.expects(:clear)
+            main = stub 'main_resource', :ref => "File[/maindir]"
+            main.expects(:to_manifest).returns "maindir"
+            second = stub 'second_resource', :ref => "File[/seconddir]"
+            second.expects(:to_manifest).returns "seconddir"
+            @settings.setting(:maindir).expects(:to_resource).returns main
+            @settings.setting(:seconddir).expects(:to_resource).returns second
 
-            # We don't care about the raised exception, we just care that
-            # we clear the catalog even with the exception
-            lambda { @settings.use(:mysection) }.should raise_error
+            @settings.to_manifest.split("\n\n").sort.should == %w{maindir seconddir}
         end
+    end
 
-        it "should do nothing if all specified sections have already been used" do
-            bucket = mock 'bucket'
-            catalog = mock 'catalog'
-
-            @settings.expects(:to_transportable).once.returns(bucket)
-            bucket.expects(:to_catalog).returns catalog
-            catalog.stub_everything
+    describe "when using sections of the configuration to manage the local host" do
+        before do
+            @settings = Puppet::Util::Settings.new
+            @settings.stubs(:service_user_available?).returns true
+            @settings.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "a"]
+            @settings.setdefaults :main, :user => ["suser", "doc"], :group => ["sgroup", "doc"]
+            @settings.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "service", :group => "service", :mode => 0755}
+            @settings.setdefaults :third, :thirddir => ["/thirddir", "b"]
+            @settings.setdefaults :files, :myfile => {:default => "/myfile", :desc => "a", :mode => 0755}
+        end
 
-            @settings.use(:whatever)
+        it "should provide a method that writes files with the correct modes" do
+            @settings.should respond_to(:write)
+        end
 
-            @settings.use(:whatever)
+        it "should provide a method that creates directories with the correct modes" do
+            Puppet::Util::SUIDManager.expects(:asuser).with("suser", "sgroup").yields
+            Dir.expects(:mkdir).with("/otherdir", 0755)
+            @settings.mkdir(:otherdir)
         end
 
-        it "should ignore file settings whose values are not strings" do
-            @settings[:maindir] = false
+        it "should create a catalog with the specified sections" do
+            @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
+            @settings.use(:main, :other)
+        end
 
-            lambda { trans = @settings.to_transportable }.should_not raise_error
+        it "should canonicalize the sections" do
+            @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
+            @settings.use("main", "other")
         end
 
-        it "should be able to turn the current configuration into a parseable manifest"
+        it "should ignore sections that have already been used" do
+            @settings.expects(:to_catalog).with(:main).returns Puppet::Resource::Catalog.new("foo")
+            @settings.use(:main)
+            @settings.expects(:to_catalog).with(:other).returns Puppet::Resource::Catalog.new("foo")
+            @settings.use(:main, :other)
+        end
 
-        it "should convert octal numbers correctly when producing a manifest"
+        it "should ignore tags and schedules when creating files and directories"
 
         it "should be able to provide all of its parameters in a format compatible with GetOpt::Long" do
             pending "Not converted from test/unit yet"
         end
 
-        it "should not attempt to manage files within /dev" do
-            pending "Not converted from test/unit yet"
-        end
+        it "should convert the created catalog to a RAL catalog" do
+            @catalog = Puppet::Resource::Catalog.new("foo")
+            @settings.expects(:to_catalog).with(:main).returns @catalog
 
-        it "should not modify the stored state database when managing resources" do
-            Puppet::Util::Storage.expects(:store).never
-            Puppet::Util::Storage.expects(:load).never
-            Dir.expects(:mkdir).with("/maindir")
-            Dir.expects(:mkdir).with("/seconddir")
+            @catalog.expects(:to_ral).returns @catalog
             @settings.use(:main)
         end
 
-        it "should convert all relative paths to fully-qualified paths (#795)" do
-            @settings[:myfile] = "unqualified"
-            dir = Dir.getwd
-            @settings[:myfile].should == File.join(dir, "unqualified")
+        it "should specify that it is not managing a host catalog" do
+            catalog = Puppet::Resource::Catalog.new("foo")
+            @settings.expects(:to_catalog).returns catalog
+
+            catalog.stubs(:to_ral).returns catalog
+
+            catalog.expects(:host_config=).with false
+
+            @settings.use(:main)
         end
 
         it "should support a method for re-using all currently used sections" do
-            Dir.expects(:mkdir).with("/thirddir").times(2)
-            @settings.use(:third)
+            @settings.expects(:to_catalog).with(:main, :third).times(2).returns Puppet::Resource::Catalog.new("foo")
+
+            @settings.use(:main, :third)
             @settings.reuse
         end
 
         it "should fail with an appropriate message if any resources fail" do
-            stub_transaction
+            @catalog = Puppet::Resource::Catalog.new("foo")
+            @catalog.stubs(:to_ral).returns @catalog
+            @settings.expects(:to_catalog).returns @catalog
+
+            @trans = mock("transaction")
+            @catalog.expects(:apply).yields(@trans)
+
             @trans.expects(:any_failed?).returns(true)
+
             report = mock 'report'
             @trans.expects(:report).returns report
 
@@ -718,8 +797,6 @@ describe Puppet::Util::Settings do
             @settings.expects(:raise).with { |msg| msg.include?("My failure") }
             @settings.use(:whatever)
         end
-
-        after { Puppet::Type.allclear }
     end
 
     describe "when dealing with printing configs" do
@@ -844,4 +921,76 @@ describe Puppet::Util::Settings do
             end
         end
     end
+
+    describe "when setting a timer to trigger configuration file reparsing" do
+        before do
+            @settings = Puppet::Util::Settings.new
+            @settings.setdefaults :foo, :filetimeout => [5, "eh"]
+        end
+
+        it "should do nothing if no filetimeout setting is available" do
+            @settings.expects(:value).with(:filetimeout).returns nil
+            EventLoop::Timer.expects(:new).never
+            @settings.set_filetimeout_timer
+        end
+
+        it "should always convert the timer interval to an integer" do
+            @settings.expects(:value).with(:filetimeout).returns "10"
+            EventLoop::Timer.expects(:new).with(:interval => 10, :start? => true, :tolerance => 1)
+            @settings.set_filetimeout_timer
+        end
+
+        it "should do nothing if the filetimeout setting is not greater than 0" do
+            @settings.expects(:value).with(:filetimeout).returns -2
+            EventLoop::Timer.expects(:new).never
+            @settings.set_filetimeout_timer
+        end
+
+        it "should create a timer with its interval set to the filetimeout, start? set to true, and a tolerance of 1" do
+            @settings.expects(:value).with(:filetimeout).returns 5
+            EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1)
+
+            @settings.set_filetimeout_timer
+        end
+
+        it "should reparse when the timer goes off" do
+            EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1).yields
+
+            @settings.expects(:reparse)
+
+            @settings.set_filetimeout_timer
+        end
+    end
+
+    describe "when determining if the service user is available" do
+        it "should return false if there is no user setting" do
+            Puppet::Util::Settings.new.should_not be_service_user_available
+        end
+
+        it "should return false if the user provider says the user is missing" do
+            settings = Puppet::Util::Settings.new
+            settings.setdefaults :main, :user => ["foo", "doc"]
+
+            user = mock 'user'
+            user.expects(:exists?).returns false
+
+            Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == "foo" }.returns user
+
+            settings.should_not be_service_user_available
+        end
+
+        it "should return true if the user provider says the user is present" do
+            settings = Puppet::Util::Settings.new
+            settings.setdefaults :main, :user => ["foo", "doc"]
+
+            user = mock 'user'
+            user.expects(:exists?).returns true
+
+            Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == "foo" }.returns user
+
+            settings.should be_service_user_available
+        end
+
+        it "should cache the result"
+    end
 end