diff --git a/lib/puppet/file_serving/configuration.rb b/lib/puppet/file_serving/configuration.rb
index 387f16667..02bca1bea 100644
--- a/lib/puppet/file_serving/configuration.rb
+++ b/lib/puppet/file_serving/configuration.rb
@@ -1,123 +1,121 @@
+require 'monitor'
 require 'puppet'
 require 'puppet/file_serving'
 require 'puppet/file_serving/mount'
 require 'puppet/file_serving/mount/file'
 require 'puppet/file_serving/mount/modules'
 require 'puppet/file_serving/mount/plugins'
-require 'puppet/util/cacher'
 
 class Puppet::FileServing::Configuration
   require 'puppet/file_serving/configuration/parser'
 
-  class << self
-    include Puppet::Util::Cacher
-    cached_attr(:configuration) { new }
+  extend MonitorMixin
+
+  def self.configuration
+    synchronize do
+      @configuration ||= new
+    end
   end
 
   Mount = Puppet::FileServing::Mount
 
-  # Create our singleton configuration.
-  def self.create
-    configuration
-  end
-
   private_class_method  :new
 
   attr_reader :mounts
   #private :mounts
 
   # Find the right mount.  Does some shenanigans to support old-style module
   # mounts.
   def find_mount(mount_name, environment)
     # Reparse the configuration if necessary.
     readconfig
 
     if mount = mounts[mount_name]
       return mount
     end
 
     if environment.module(mount_name)
       Puppet::Util::Warnings.notice_once "DEPRECATION NOTICE: Files found in modules without specifying 'modules' in file path will be deprecated in the next major release.  Please fix module '#{mount_name}' when no 0.24.x clients are present"
       return mounts["modules"]
     end
 
     # This can be nil.
     mounts[mount_name]
   end
 
   def initialize
     @mounts = {}
     @config_file = nil
 
     # We don't check to see if the file is modified the first time,
     # because we always want to parse at first.
     readconfig(false)
   end
 
   # Is a given mount available?
   def mounted?(name)
     @mounts.include?(name)
   end
 
   # Split the path into the separate mount point and path.
   def split_path(request)
     # Reparse the configuration if necessary.
     readconfig
 
     mount_name, path = request.key.split(File::Separator, 2)
 
     raise(ArgumentError, "Cannot find file: Invalid path '#{mount_name}'") unless mount_name =~ %r{^[-\w]+$}
 
     return nil unless mount = find_mount(mount_name, request.environment)
     if mount.name == "modules" and mount_name != "modules"
       # yay backward-compatibility
       path = "#{mount_name}/#{path}"
     end
 
     if path == ""
       path = nil
     elsif path
       # Remove any double slashes that might have occurred
       path = path.gsub(/\/+/, "/")
     end
 
     return mount, path
   end
 
   def umount(name)
     @mounts.delete(name) if @mounts.include? name
   end
 
   private
 
   def mk_default_mounts
     @mounts["modules"] ||= Mount::Modules.new("modules")
     @mounts["modules"].allow('*') if @mounts["modules"].empty?
     @mounts["plugins"] ||= Mount::Plugins.new("plugins")
     @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
   end
 
   # Read the configuration file.
   def readconfig(check = true)
     config = Puppet[:fileserverconfig]
 
     return unless FileTest.exists?(config)
 
     @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
 
     return if check and ! @parser.changed?
 
     # Don't assign the mounts hash until we're sure the parsing succeeded.
     begin
       newmounts = @parser.parse
       @mounts = newmounts
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Error parsing fileserver configuration: #{detail}; using old configuration"
     end
 
   ensure
     # Make sure we've got our plugins and modules.
     mk_default_mounts
   end
 end
diff --git a/lib/puppet/indirector/file_server.rb b/lib/puppet/indirector/file_server.rb
index a1a5c0a44..9516a404c 100644
--- a/lib/puppet/indirector/file_server.rb
+++ b/lib/puppet/indirector/file_server.rb
@@ -1,65 +1,65 @@
 require 'puppet/file_serving/configuration'
 require 'puppet/file_serving/fileset'
 require 'puppet/file_serving/terminus_helper'
 require 'puppet/indirector/terminus'
 
 # Look files up using the file server.
 class Puppet::Indirector::FileServer < Puppet::Indirector::Terminus
   include Puppet::FileServing::TerminusHelper
 
   # Is the client authorized to perform this action?
   def authorized?(request)
     return false unless [:find, :search].include?(request.method)
 
     mount, file_path = configuration.split_path(request)
 
     # If we're not serving this mount, then access is denied.
     return false unless mount
     mount.allowed?(request.node, request.ip)
   end
 
   # Find our key using the fileserver.
   def find(request)
     mount, relative_path = configuration.split_path(request)
 
     return nil unless mount
 
     # The mount checks to see if the file exists, and returns nil
     # if not.
     return nil unless path = mount.find(relative_path, request)
     result = model.new(path)
     result.links = request.options[:links] if request.options[:links]
     result.collect
     result
   end
 
   # Search for files.  This returns an array rather than a single
   # file.
   def search(request)
     mount, relative_path = configuration.split_path(request)
 
     unless mount and paths = mount.search(relative_path, request)
       Puppet.info "Could not find filesystem info for file '#{request.key}' in environment #{request.environment}"
       return nil
     end
 
     filesets = paths.collect do |path|
       # Filesets support indirector requests as an options collection
       Puppet::FileServing::Fileset.new(path, request)
     end
 
     Puppet::FileServing::Fileset.merge(*filesets).collect do |file, base_path|
       inst = model.new(base_path, :relative_path => file)
       inst.links = request.options[:links] if request.options[:links]
       inst.collect
       inst
     end
   end
 
   private
 
   # Our fileserver configuration, if needed.
   def configuration
-    Puppet::FileServing::Configuration.create
+    Puppet::FileServing::Configuration.configuration
   end
 end
diff --git a/spec/integration/indirector/file_content/file_server_spec.rb b/spec/integration/indirector/file_content/file_server_spec.rb
index c068d76d5..3be32754f 100755
--- a/spec/integration/indirector/file_content/file_server_spec.rb
+++ b/spec/integration/indirector/file_content/file_server_spec.rb
@@ -1,90 +1,90 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/file_server'
 require 'shared_behaviours/file_server_terminus'
 
 require 'puppet_spec/files'
 
 describe Puppet::Indirector::FileContent::FileServer, " when finding files", :fails_on_windows => true do
   it_should_behave_like "Puppet::Indirector::FileServerTerminus"
   include PuppetSpec::Files
 
   before do
     @terminus = Puppet::Indirector::FileContent::FileServer.new
     @test_class = Puppet::FileServing::Content
+    Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
   end
 
   it "should find plugin file content in the environment specified in the request" do
     path = tmpfile("file_content_with_env")
 
     Dir.mkdir(path)
 
     modpath = File.join(path, "mod")
     FileUtils.mkdir_p(File.join(modpath, "lib"))
     file = File.join(modpath, "lib", "file.rb")
     File.open(file, "w") { |f| f.puts "1" }
 
     Puppet.settings[:modulepath] = "/no/such/file"
 
     env = Puppet::Node::Environment.new("foo")
     env.stubs(:modulepath).returns [path]
 
     result = Puppet::FileServing::Content.indirection.search("plugins", :environment => "foo", :recurse => true)
 
     result.should_not be_nil
     result.length.should == 2
     result[1].should be_instance_of(Puppet::FileServing::Content)
     result[1].content.should == "1\n"
   end
 
   it "should find file content in modules" do
     path = tmpfile("file_content")
 
     Dir.mkdir(path)
 
     modpath = File.join(path, "mymod")
     FileUtils.mkdir_p(File.join(modpath, "files"))
     file = File.join(modpath, "files", "myfile")
     File.open(file, "w") { |f| f.puts "1" }
 
     Puppet.settings[:modulepath] = path
 
     result = Puppet::FileServing::Content.indirection.find("modules/mymod/myfile")
 
     result.should_not be_nil
     result.should be_instance_of(Puppet::FileServing::Content)
     result.content.should == "1\n"
   end
 
   it "should find file content in files when node name expansions are used" do
-    Puppet::Util::Cacher.expire
     FileTest.stubs(:exists?).returns true
     FileTest.stubs(:exists?).with(Puppet[:fileserverconfig]).returns(true)
 
     @path = tmpfile("file_server_testing")
 
     Dir.mkdir(@path)
     subdir = File.join(@path, "mynode")
     Dir.mkdir(subdir)
     File.open(File.join(subdir, "myfile"), "w") { |f| f.puts "1" }
 
     # Use a real mount, so the integration is a bit deeper.
     @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
     @mount1.stubs(:allowed?).returns true
     @mount1.path = File.join(@path, "%h")
 
     @parser = stub 'parser', :changed? => false
     @parser.stubs(:parse).returns("one" => @mount1)
 
     Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
 
     path = File.join(@path, "myfile")
 
     result = Puppet::FileServing::Content.indirection.find("one/myfile", :environment => "foo", :node => "mynode")
 
     result.should_not be_nil
     result.should be_instance_of(Puppet::FileServing::Content)
     result.content.should == "1\n"
   end
 end
diff --git a/spec/shared_behaviours/file_server_terminus.rb b/spec/shared_behaviours/file_server_terminus.rb
index e300d9b4d..33037e551 100755
--- a/spec/shared_behaviours/file_server_terminus.rb
+++ b/spec/shared_behaviours/file_server_terminus.rb
@@ -1,41 +1,41 @@
 #!/usr/bin/env rspec
 shared_examples_for "Puppet::Indirector::FileServerTerminus" do
   # This only works if the shared behaviour is included before
   # the 'before' block in the including context.
   before do
-    Puppet::Util::Cacher.expire
+    Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
     FileTest.stubs(:exists?).returns true
     FileTest.stubs(:exists?).with(Puppet[:fileserverconfig]).returns(true)
 
     @path = Tempfile.new("file_server_testing")
     path = @path.path
     @path.close!
     @path = path
 
     Dir.mkdir(@path)
     File.open(File.join(@path, "myfile"), "w") { |f| f.print "my content" }
 
     # Use a real mount, so the integration is a bit deeper.
     @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
     @mount1.path = @path
 
     @parser = stub 'parser', :changed? => false
     @parser.stubs(:parse).returns("one" => @mount1)
 
     Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
 
     # Stub out the modules terminus
     @modules = mock 'modules terminus'
 
     @request = Puppet::Indirector::Request.new(:indirection, :method, "puppet://myhost/one/myfile")
   end
 
   it "should use the file server configuration to find files" do
     @modules.stubs(:find).returns(nil)
     @terminus.indirection.stubs(:terminus).with(:modules).returns(@modules)
 
     path = File.join(@path, "myfile")
 
     @terminus.find(@request).should be_instance_of(@test_class)
   end
 end
diff --git a/spec/unit/file_serving/configuration_spec.rb b/spec/unit/file_serving/configuration_spec.rb
index ed8663853..a1546c987 100755
--- a/spec/unit/file_serving/configuration_spec.rb
+++ b/spec/unit/file_serving/configuration_spec.rb
@@ -1,249 +1,237 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/configuration'
 
-describe Puppet::FileServing::Configuration, :fails_on_windows => true do
-  it "should make :new a private method" do
-    proc { Puppet::FileServing::Configuration.new }.should raise_error
-  end
-
-  it "should return the same configuration each time :create is called" do
-    Puppet::FileServing::Configuration.create.should equal(Puppet::FileServing::Configuration.create)
-  end
-
-  it "should have a method for removing the current configuration instance" do
-    old = Puppet::FileServing::Configuration.create
-    Puppet::Util::Cacher.expire
-    Puppet::FileServing::Configuration.create.should_not equal(old)
-  end
-
-  after do
-    Puppet::Util::Cacher.expire
-  end
-end
-
 describe Puppet::FileServing::Configuration do
   include PuppetSpec::Files
 
   before :each do
     @path = make_absolute("/path/to/configuration/file.conf")
     Puppet.settings.stubs(:value).with(:trace).returns(false)
     Puppet.settings.stubs(:value).with(:fileserverconfig).returns(@path)
   end
 
   after :each do
-    Puppet::Util::Cacher.expire
+    Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
+  end
+
+  it "should make :new a private method" do
+    proc { Puppet::FileServing::Configuration.new }.should raise_error
+  end
+
+  it "should return the same configuration each time 'configuration' is called" do
+    Puppet::FileServing::Configuration.configuration.should equal(Puppet::FileServing::Configuration.configuration)
   end
 
   describe "when initializing" do
 
     it "should work without a configuration file" do
       FileTest.stubs(:exists?).with(@path).returns(false)
-      proc { Puppet::FileServing::Configuration.create }.should_not raise_error
+      proc { Puppet::FileServing::Configuration.configuration }.should_not raise_error
     end
 
     it "should parse the configuration file if present" do
       FileTest.stubs(:exists?).with(@path).returns(true)
       @parser = mock 'parser'
       @parser.expects(:parse).returns({})
       Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
-      Puppet::FileServing::Configuration.create
+      Puppet::FileServing::Configuration.configuration
     end
 
     it "should determine the path to the configuration file from the Puppet settings" do
-      Puppet::FileServing::Configuration.create
+      Puppet::FileServing::Configuration.configuration
     end
   end
 
   describe "when parsing the configuration file" do
 
     before do
       FileTest.stubs(:exists?).with(@path).returns(true)
       @parser = mock 'parser'
       Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
     end
 
     it "should set the mount list to the results of parsing" do
       @parser.expects(:parse).returns("one" => mock("mount"))
-      config = Puppet::FileServing::Configuration.create
+      config = Puppet::FileServing::Configuration.configuration
       config.mounted?("one").should be_true
     end
 
     it "should not raise exceptions" do
       @parser.expects(:parse).raises(ArgumentError)
-      proc { Puppet::FileServing::Configuration.create }.should_not raise_error
+      proc { Puppet::FileServing::Configuration.configuration }.should_not raise_error
     end
 
     it "should replace the existing mount list with the results of reparsing" do
       @parser.expects(:parse).returns("one" => mock("mount"))
-      config = Puppet::FileServing::Configuration.create
+      config = Puppet::FileServing::Configuration.configuration
       config.mounted?("one").should be_true
       # Now parse again
       @parser.expects(:parse).returns("two" => mock('other'))
       config.send(:readconfig, false)
       config.mounted?("one").should be_false
       config.mounted?("two").should be_true
     end
 
     it "should not replace the mount list until the file is entirely parsed successfully" do
       @parser.expects(:parse).returns("one" => mock("mount"))
       @parser.expects(:parse).raises(ArgumentError)
-      config = Puppet::FileServing::Configuration.create
+      config = Puppet::FileServing::Configuration.configuration
       # Now parse again, so the exception gets thrown
       config.send(:readconfig, false)
       config.mounted?("one").should be_true
     end
 
     it "should add modules and plugins mounts even if the file does not exist" do
       FileTest.expects(:exists?).returns false # the file doesn't exist
-      config = Puppet::FileServing::Configuration.create
+      config = Puppet::FileServing::Configuration.configuration
       config.mounted?("modules").should be_true
       config.mounted?("plugins").should be_true
     end
 
     it "should allow all access to modules and plugins if no fileserver.conf exists" do
       FileTest.expects(:exists?).returns false # the file doesn't exist
       modules = stub 'modules', :empty? => true
       Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
       modules.expects(:allow).with('*')
 
       plugins = stub 'plugins', :empty? => true
       Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
       plugins.expects(:allow).with('*')
 
-      Puppet::FileServing::Configuration.create
+      Puppet::FileServing::Configuration.configuration
     end
 
     it "should not allow access from all to modules and plugins if the fileserver.conf provided some rules" do
       FileTest.expects(:exists?).returns false # the file doesn't exist
 
       modules = stub 'modules', :empty? => false
       Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
       modules.expects(:allow).with('*').never
 
       plugins = stub 'plugins', :empty? => false
       Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
       plugins.expects(:allow).with('*').never
 
-      Puppet::FileServing::Configuration.create
+      Puppet::FileServing::Configuration.configuration
     end
 
     it "should add modules and plugins mounts even if they are not returned by the parser" do
       @parser.expects(:parse).returns("one" => mock("mount"))
       FileTest.expects(:exists?).returns true # the file doesn't exist
-      config = Puppet::FileServing::Configuration.create
+      config = Puppet::FileServing::Configuration.configuration
       config.mounted?("modules").should be_true
       config.mounted?("plugins").should be_true
     end
   end
 
   describe "when finding the specified mount" do
     it "should choose the named mount if one exists" do
-      config = Puppet::FileServing::Configuration.create
+      config = Puppet::FileServing::Configuration.configuration
       config.expects(:mounts).returns("one" => "foo")
       config.find_mount("one", mock('env')).should == "foo"
     end
 
     it "should use the provided environment to find a matching module if the named module cannot be found" do
-      config = Puppet::FileServing::Configuration.create
+      config = Puppet::FileServing::Configuration.configuration
 
       mod = mock 'module'
       env = mock 'environment'
       env.expects(:module).with("foo").returns mod
       mount = mock 'mount'
 
       config.stubs(:mounts).returns("modules" => mount)
       Puppet::Util::Warnings.expects(:notice_once)
       config.find_mount("foo", env).should equal(mount)
     end
 
     it "should return nil if there is no such named mount and no module with the same name exists" do
-      config = Puppet::FileServing::Configuration.create
+      config = Puppet::FileServing::Configuration.configuration
 
       env = mock 'environment'
       env.expects(:module).with("foo").returns nil
 
       mount = mock 'mount'
       config.stubs(:mounts).returns("modules" => mount)
       config.find_mount("foo", env).should be_nil
     end
   end
 
   describe "when finding the mount name and relative path in a request key" do
     before do
-      @config = Puppet::FileServing::Configuration.create
+      @config = Puppet::FileServing::Configuration.configuration
       @config.stubs(:find_mount)
 
       @request = stub 'request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => mock("env")
     end
 
     it "should reread the configuration" do
       @config.expects(:readconfig)
 
       @config.split_path(@request)
     end
 
     it "should treat the first field of the URI path as the mount name" do
       @config.expects(:find_mount).with { |name, node| name == "foo" }
 
       @config.split_path(@request)
     end
 
     it "should fail if the mount name is not alpha-numeric" do
       @request.expects(:key).returns "foo&bar/asdf"
 
       lambda { @config.split_path(@request) }.should raise_error(ArgumentError)
     end
 
     it "should support dashes in the mount name" do
       @request.expects(:key).returns "foo-bar/asdf"
 
       lambda { @config.split_path(@request) }.should_not raise_error(ArgumentError)
     end
 
     it "should use the mount name and environment to find the mount" do
       @config.expects(:find_mount).with { |name, env| name == "foo" and env == @request.environment }
       @request.stubs(:node).returns("mynode")
 
       @config.split_path(@request)
     end
 
     it "should return nil if the mount cannot be found" do
       @config.expects(:find_mount).returns nil
 
       @config.split_path(@request).should be_nil
     end
 
     it "should return the mount and the relative path if the mount is found" do
       mount = stub 'mount', :name => "foo"
       @config.expects(:find_mount).returns mount
 
       @config.split_path(@request).should == [mount, "bar/baz"]
     end
 
     it "should remove any double slashes" do
       @request.stubs(:key).returns "foo/bar//baz"
       mount = stub 'mount', :name => "foo"
       @config.expects(:find_mount).returns mount
 
       @config.split_path(@request).should == [mount, "bar/baz"]
     end
 
     it "should return the relative path as nil if it is an empty string" do
       @request.expects(:key).returns "foo"
       mount = stub 'mount', :name => "foo"
       @config.expects(:find_mount).returns mount
 
       @config.split_path(@request).should == [mount, nil]
     end
 
     it "should add 'modules/' to the relative path if the modules mount is used but not specified, for backward compatibility" do
       @request.expects(:key).returns "foo/bar"
       mount = stub 'mount', :name => "modules"
       @config.expects(:find_mount).returns mount
 
       @config.split_path(@request).should == [mount, "foo/bar"]
     end
   end
 end
diff --git a/spec/unit/indirector/file_server_spec.rb b/spec/unit/indirector/file_server_spec.rb
index b0227772b..8f7a5d1b3 100755
--- a/spec/unit/indirector/file_server_spec.rb
+++ b/spec/unit/indirector/file_server_spec.rb
@@ -1,263 +1,263 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/file_server'
 require 'puppet/file_serving/configuration'
 
 describe Puppet::Indirector::FileServer do
 
   before :all do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
     module Testing; end
     @file_server_class = class Testing::MyFileServer < Puppet::Indirector::FileServer
       self
     end
   end
 
   before :each do
     @file_server = @file_server_class.new
 
     @uri = "puppet://host/my/local/file"
     @configuration = mock 'configuration'
-    Puppet::FileServing::Configuration.stubs(:create).returns(@configuration)
+    Puppet::FileServing::Configuration.stubs(:configuration).returns(@configuration)
 
     @request = Puppet::Indirector::Request.new(:myind, :mymethod, @uri, :environment => "myenv")
   end
 
   describe "when finding files" do
     before do
       @mount = stub 'mount', :find => nil
       @instance = stub('instance', :links= => nil, :collect => nil)
     end
 
     it "should use the configuration to find the mount and relative path" do
       @configuration.expects(:split_path).with(@request)
 
       @file_server.find(@request)
     end
 
     it "should return nil if it cannot find the mount" do
       @configuration.expects(:split_path).with(@request).returns(nil, nil)
 
       @file_server.find(@request).should be_nil
     end
 
     it "should use the mount to find the full path" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }
 
       @file_server.find(@request)
     end
 
     it "should pass the request when finding a file" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| request == @request }
 
       @file_server.find(@request)
     end
 
     it "should return nil if it cannot find a full path" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }.returns nil
 
       @file_server.find(@request).should be_nil
     end
 
     it "should create an instance with the found path" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
       @model.expects(:new).with("/my/file").returns @instance
 
       @file_server.find(@request).should equal(@instance)
     end
 
     it "should set 'links' on the instance if it is set in the request options" do
       @request.options[:links] = true
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
       @model.expects(:new).with("/my/file").returns @instance
 
       @instance.expects(:links=).with(true)
 
       @file_server.find(@request).should equal(@instance)
     end
 
     it "should collect the instance" do
       @request.options[:links] = true
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
       @model.expects(:new).with("/my/file").returns @instance
 
       @instance.expects(:collect)
 
       @file_server.find(@request).should equal(@instance)
     end
   end
 
   describe "when searching for instances" do
     before do
       @mount = stub 'mount', :search => nil
       @instance = stub('instance', :links= => nil, :collect => nil)
     end
 
     it "should use the configuration to search the mount and relative path" do
       @configuration.expects(:split_path).with(@request)
 
       @file_server.search(@request)
     end
 
     it "should return nil if it cannot search the mount" do
       @configuration.expects(:split_path).with(@request).returns(nil, nil)
 
       @file_server.search(@request).should be_nil
     end
 
     it "should use the mount to search for the full paths" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }
 
       @file_server.search(@request)
     end
 
     it "should pass the request" do
       @configuration.stubs(:split_path).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| request == @request }
 
       @file_server.search(@request)
     end
 
     it "should return nil if searching does not find any full paths" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns nil
 
       @file_server.search(@request).should be_nil
     end
 
     it "should create a fileset with each returned path and merge them" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns %w{/one /two}
 
       FileTest.stubs(:exist?).returns true
 
       one = mock 'fileset_one'
       Puppet::FileServing::Fileset.expects(:new).with("/one", @request).returns(one)
       two = mock 'fileset_two'
       Puppet::FileServing::Fileset.expects(:new).with("/two", @request).returns(two)
 
       Puppet::FileServing::Fileset.expects(:merge).with(one, two).returns []
 
       @file_server.search(@request)
     end
 
     it "should create an instance with each path resulting from the merger of the filesets" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
       FileTest.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one", "two" => "/two")
 
       one = stub 'one', :collect => nil
       @model.expects(:new).with("/one", :relative_path => "one").returns one
 
       two = stub 'two', :collect => nil
       @model.expects(:new).with("/two", :relative_path => "two").returns two
 
       # order can't be guaranteed
       result = @file_server.search(@request)
       result.should be_include(one)
       result.should be_include(two)
       result.length.should == 2
     end
 
     it "should set 'links' on the instances if it is set in the request options" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
       FileTest.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
       one = stub 'one', :collect => nil
       @model.expects(:new).with("/one", :relative_path => "one").returns one
       one.expects(:links=).with true
 
       @request.options[:links] = true
 
       @file_server.search(@request)
     end
 
     it "should collect the instances" do
       @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
       @mount.expects(:search).with { |key, options| key == "rel/path" }.returns []
 
       FileTest.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
       one = mock 'one'
       @model.expects(:new).with("/one", :relative_path => "one").returns one
       one.expects(:collect)
 
       @file_server.search(@request)
     end
   end
 
   describe "when checking authorization" do
     before do
       @request.method = :find
 
       @mount = stub 'mount'
       @configuration.stubs(:split_path).with(@request).returns([@mount, "rel/path"])
       @request.stubs(:node).returns("mynode")
       @request.stubs(:ip).returns("myip")
       @mount.stubs(:allowed?).with("mynode", "myip").returns "something"
     end
 
     it "should return false when destroying" do
       @request.method = :destroy
       @file_server.should_not be_authorized(@request)
     end
 
     it "should return false when saving" do
       @request.method = :save
       @file_server.should_not be_authorized(@request)
     end
 
     it "should use the configuration to find the mount and relative path" do
       @configuration.expects(:split_path).with(@request)
 
       @file_server.authorized?(@request)
     end
 
     it "should return false if it cannot find the mount" do
       @configuration.expects(:split_path).with(@request).returns(nil, nil)
 
       @file_server.should_not be_authorized(@request)
     end
 
     it "should return the results of asking the mount whether the node and IP are authorized" do
       @file_server.authorized?(@request).should == "something"
     end
   end
 end