1 files changed, 197 insertions, 197 deletions
diff --git a/spec/unit/file_serving/configuration_spec.rb b/spec/unit/file_serving/configuration_spec.rb
index 4621a0c82..3e11caa08 100755
--- a/spec/unit/file_serving/configuration_spec.rb
+++ b/spec/unit/file_serving/configuration_spec.rb
@@ -5,245 +5,245 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/file_serving/configuration'
 
 describe Puppet::FileServing::Configuration do
-    it "should make :new a private method" do
-        proc { Puppet::FileServing::Configuration.new }.should raise_error
+  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
+
+  before :each do
+    @path = "/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
+  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
     end
 
-    it "should return the same configuration each time :create is called" do
-        Puppet::FileServing::Configuration.create.should equal(Puppet::FileServing::Configuration.create)
+    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
     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)
+    it "should determine the path to the configuration file from the Puppet settings" do
+      Puppet::FileServing::Configuration.create
     end
+  end
+
+  describe "when parsing the configuration file" do
 
-    after do
-        Puppet::Util::Cacher.expire
+    before do
+      FileTest.stubs(:exists?).with(@path).returns(true)
+      @parser = mock 'parser'
+      Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
     end
-end
 
-describe Puppet::FileServing::Configuration do
+    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.mounted?("one").should be_true
+    end
 
-    before :each do
-        @path = "/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
-    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
-        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
-        end
-
-        it "should determine the path to the configuration file from the Puppet settings" do
-            Puppet::FileServing::Configuration.create
-        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.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
-        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.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
-            # 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.mounted?("modules").should be_true
-            config.mounted?("plugins").should be_true
-        end
+    it "should not raise exceptions" do
+      @parser.expects(:parse).raises(ArgumentError)
+      proc { Puppet::FileServing::Configuration.create }.should_not raise_error
+    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('*')
+    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.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
 
-            plugins = stub 'plugins', :empty? => true
-            Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
-            plugins.expects(:allow).with('*')
+    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
+      # Now parse again, so the exception gets thrown
+      config.send(:readconfig, false)
+      config.mounted?("one").should be_true
+    end
 
-            Puppet::FileServing::Configuration.create
-        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.mounted?("modules").should be_true
+      config.mounted?("plugins").should be_true
+    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
+    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('*')
 
-            modules = stub 'modules', :empty? => false
-            Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
-            modules.expects(:allow).with('*').never
+      plugins = stub 'plugins', :empty? => true
+      Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
+      plugins.expects(:allow).with('*')
 
-            plugins = stub 'plugins', :empty? => false
-            Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
-            plugins.expects(:allow).with('*').never
+      Puppet::FileServing::Configuration.create
+    end
 
-            Puppet::FileServing::Configuration.create
-        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
 
-        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.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.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
+      modules = stub 'modules', :empty? => false
+      Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
+      modules.expects(:allow).with('*').never
 
-            mod = mock 'module'
-            env = mock 'environment'
-            env.expects(:module).with("foo").returns mod
-            mount = mock 'mount'
+      plugins = stub 'plugins', :empty? => false
+      Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
+      plugins.expects(:allow).with('*').never
 
-            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
-
-            env = mock 'environment'
-            env.expects(:module).with("foo").returns nil
+      Puppet::FileServing::Configuration.create
+    end
 
-            mount = mock 'mount'
-            config.stubs(:mounts).returns("modules" => mount)
-            config.find_mount("foo", env).should be_nil
-        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.mounted?("modules").should be_true
+      config.mounted?("plugins").should be_true
     end
+  end
 
-    describe "when finding the mount name and relative path in a request key" do
-        before do
-            @config = Puppet::FileServing::Configuration.create
-            @config.stubs(:find_mount)
+  describe "when finding the specified mount" do
+    it "should choose the named mount if one exists" do
+      config = Puppet::FileServing::Configuration.create
+      config.expects(:mounts).returns("one" => "foo")
+      config.find_mount("one", mock('env')).should == "foo"
+    end
 
-            @request = stub 'request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => mock("env")
-        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
 
-        it "should reread the configuration" do
-            @config.expects(:readconfig)
+      mod = mock 'module'
+      env = mock 'environment'
+      env.expects(:module).with("foo").returns mod
+      mount = mock 'mount'
 
-            @config.split_path(@request)
-        end
+      config.stubs(:mounts).returns("modules" => mount)
+      Puppet::Util::Warnings.expects(:notice_once)
+      config.find_mount("foo", env).should equal(mount)
+    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" }
+    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.split_path(@request)
-        end
+      env = mock 'environment'
+      env.expects(:module).with("foo").returns nil
 
-        it "should fail if the mount name is not alpha-numeric" do
-            @request.expects(:key).returns "foo&bar/asdf"
+      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.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
 
-            lambda { @config.split_path(@request) }.should raise_error(ArgumentError)
-        end
+    it "should fail if the mount name is not alpha-numeric" do
+      @request.expects(:key).returns "foo&bar/asdf"
 
-        it "should support dashes in the mount name" do
-            @request.expects(:key).returns "foo-bar/asdf"
+      lambda { @config.split_path(@request) }.should raise_error(ArgumentError)
+    end
 
-            lambda { @config.split_path(@request) }.should_not raise_error(ArgumentError)
-        end
+    it "should support dashes in the mount name" do
+      @request.expects(:key).returns "foo-bar/asdf"
 
-        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")
+      lambda { @config.split_path(@request) }.should_not raise_error(ArgumentError)
+    end
 
-            @config.split_path(@request)
-        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")
 
-        it "should return nil if the mount cannot be found" do
-            @config.expects(:find_mount).returns nil
+      @config.split_path(@request)
+    end
 
-            @config.split_path(@request).should be_nil
-        end
+    it "should return nil if the mount cannot be found" do
+      @config.expects(:find_mount).returns nil
 
-        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 be_nil
+    end
 
-            @config.split_path(@request).should == [mount, "bar/baz"]
-        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
 
-        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 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
+      @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
+    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
+      @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
+    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
+      @config.split_path(@request).should == [mount, "foo/bar"]
     end
+  end
 end