puppet 0.24.9 → 0.25.0

data/spec/unit/daemon.rb

@@ -0,0 +1,287 @@
+#!/usr/bin/env ruby"
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'puppet/daemon'
+
+describe Puppet::Daemon do
+    before do
+        @daemon = Puppet::Daemon.new
+    end
+
+    it "should be able to manage an agent" do
+        @daemon.should respond_to(:agent)
+    end
+
+    it "should be able to manage a network server" do
+        @daemon.should respond_to(:server)
+    end
+
+    it "should reopen the Log logs when told to reopen logs" do
+        Puppet::Util::Log.expects(:reopen)
+        @daemon.reopen_logs
+    end
+
+    describe "when setting signal traps" do
+        before do
+            @daemon.stubs(:trap)
+        end
+
+        {:INT => :stop, :TERM => :stop, :HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
+            it "should log and call #{method} when it receives #{signal}" do
+                @daemon.expects(:trap).with(signal).yields
+
+                Puppet.expects(:notice)
+
+                @daemon.expects(method)
+
+                @daemon.set_signal_traps
+            end
+        end
+    end
+
+    describe "when starting" do
+        before do
+            @daemon.stubs(:create_pidfile)
+            @daemon.stubs(:set_signal_traps)
+            EventLoop.current.stubs(:run)
+        end
+
+        it "should fail if it has neither agent nor server" do
+            lambda { @daemon.start }.should raise_error(Puppet::DevError)
+        end
+
+        it "should create its pidfile" do
+            @daemon.stubs(:agent).returns stub('agent', :start => nil)
+
+            @daemon.expects(:create_pidfile)
+            @daemon.start
+        end
+
+        it "should start the agent if the agent is configured" do
+            agent = mock 'agent'
+            agent.expects(:start)
+            @daemon.stubs(:agent).returns agent
+
+            @daemon.start
+        end
+
+        it "should start its server if one is configured" do
+            server = mock 'server'
+            server.expects(:start)
+            @daemon.stubs(:server).returns server
+
+            @daemon.start
+        end
+
+        it "should let the current EventLoop run" do
+            @daemon.stubs(:agent).returns stub('agent', :start => nil)
+            EventLoop.current.expects(:run)
+
+            @daemon.start
+        end
+    end
+
+    describe "when stopping" do
+        before do
+            @daemon.stubs(:remove_pidfile)
+            @daemon.stubs(:exit)
+            Puppet::Util::Log.stubs(:close_all)
+        end
+
+        it "should stop its server if one is configured" do
+            server = mock 'server'
+            server.expects(:stop)
+            @daemon.stubs(:server).returns server
+
+            @daemon.stop
+        end
+
+        it "should stop its agent if one is configured" do
+            agent = mock 'agent'
+            agent.expects(:stop)
+            @daemon.stubs(:agent).returns agent
+
+            @daemon.stop
+        end
+
+        it "should remove its pidfile" do
+            @daemon.expects(:remove_pidfile)
+
+            @daemon.stop
+        end
+
+        it "should close all logs" do
+            Puppet::Util::Log.expects(:close_all)
+
+            @daemon.stop
+        end
+
+        it "should exit unless called with ':exit => false'" do
+            @daemon.expects(:exit)
+            @daemon.stop
+        end
+
+        it "should not exit if called with ':exit => false'" do
+            @daemon.expects(:exit).never
+            @daemon.stop :exit => false
+        end
+    end
+
+    describe "when creating its pidfile" do
+        it "should use an exclusive mutex" do
+            Puppet.settings.expects(:value).with(:name).returns "me"
+
+            sync = mock 'sync'
+            Puppet::Util.expects(:sync).with("me").returns sync
+
+            sync.expects(:synchronize).with(Sync::EX)
+            @daemon.create_pidfile
+        end
+
+        it "should lock the pidfile using the Pidlock class" do
+            pidfile = mock 'pidfile'
+
+            Puppet.settings.stubs(:value).with(:name).returns "eh"
+            Puppet.settings.expects(:value).with(:pidfile).returns "/my/file"
+
+            Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+
+            pidfile.expects(:lock).returns true
+            @daemon.create_pidfile
+        end
+
+        it "should fail if it cannot lock" do
+            pidfile = mock 'pidfile'
+
+            Puppet.settings.stubs(:value).with(:name).returns "eh"
+            Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
+
+            Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+
+            pidfile.expects(:lock).returns false
+
+            lambda { @daemon.create_pidfile }.should raise_error
+        end
+    end
+
+    describe "when removing its pidfile" do
+        it "should use an exclusive mutex" do
+            Puppet.settings.expects(:value).with(:name).returns "me"
+
+            sync = mock 'sync'
+            Puppet::Util.expects(:sync).with("me").returns sync
+
+            sync.expects(:synchronize).with(Sync::EX)
+            @daemon.remove_pidfile
+        end
+
+        it "should do nothing if the pidfile is not present" do
+            pidfile = mock 'pidfile', :locked? => false
+            Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+
+            Puppet.settings.stubs(:value).with(:name).returns "eh"
+            Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
+
+            pidfile.expects(:unlock).never
+            @daemon.remove_pidfile
+        end
+
+        it "should unlock the pidfile using the Pidlock class" do
+            pidfile = mock 'pidfile', :locked? => true
+            Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+            pidfile.expects(:unlock).returns true
+
+            Puppet.settings.stubs(:value).with(:name).returns "eh"
+            Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
+
+            @daemon.remove_pidfile
+        end
+
+        it "should warn if it cannot remove the pidfile" do
+            pidfile = mock 'pidfile', :locked? => true
+            Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+            pidfile.expects(:unlock).returns false
+
+            Puppet.settings.stubs(:value).with(:name).returns "eh"
+            Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
+
+            Puppet.expects :err
+            @daemon.remove_pidfile
+        end
+    end
+
+    describe "when reloading" do
+        it "should do nothing if no agent is configured" do
+            @daemon.reload
+        end
+
+        it "should do nothing if the agent is running" do
+            agent = mock 'agent'
+            agent.expects(:running?).returns true
+
+            @daemon.stubs(:agent).returns agent
+
+            @daemon.reload
+        end
+
+        it "should run the agent if one is available and it is not running" do
+            agent = mock 'agent'
+            agent.expects(:running?).returns false
+            agent.expects :run
+
+            @daemon.stubs(:agent).returns agent
+
+            @daemon.reload
+        end
+    end
+
+    describe "when restarting" do
+        it "should reexec itself if no agent is available" do
+            @daemon.expects(:reexec)
+
+            @daemon.restart
+        end
+
+        it "should reexec itself if the agent is not running" do
+            agent = mock 'agent'
+            agent.expects(:running?).returns false
+            @daemon.stubs(:agent).returns agent
+            @daemon.expects(:reexec)
+
+            @daemon.restart
+        end
+
+        it "should configure the agent for later restart if the agent is running" do
+            agent = mock 'agent'
+            agent.expects(:running?).returns true
+            @daemon.stubs(:agent).returns agent
+            @daemon.expects(:reexec).never
+
+            agent.expects(:configure_delayed_restart)
+
+            @daemon.restart
+        end
+    end
+
+    describe "when reexecing it self" do
+        it "should fail if no argv values are available" do
+            @daemon.expects(:argv).returns nil
+            lambda { @daemon.reexec }.should raise_error(Puppet::DevError)
+        end
+
+        it "should shut down without exiting" do
+            @daemon.argv = %w{foo}
+            @daemon.expects(:stop).with(:exit => false)
+
+            @daemon.stubs(:exec)
+            @daemon.reexec
+        end
+
+        it "should call 'exec' with the original executable and arguments" do
+            @daemon.argv = %w{foo}
+            @daemon.expects(:exec).with($0 + " " + "foo")
+
+            @daemon.reexec
+        end
+    end
+end

data/spec/unit/file_serving/{file_base.rb → base.rb}

@@ -2,67 +2,70 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-require 'puppet/file_serving/file_base'
+require 'puppet/file_serving/base'
 
-describe Puppet::FileServing::FileBase do
-    it "should accept a key in the form of a URI" do
-        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file").key.should == "puppet://host/module/dir/file"
+describe Puppet::FileServing::Base do
+    it "should accept a path" do
+        Puppet::FileServing::Base.new("/module/dir/file").path.should == "/module/dir/file"
+    end
+
+    it "should require that paths be fully qualified" do
+        lambda { Puppet::FileServing::Base.new("module/dir/file") }.should raise_error(ArgumentError)
     end
 
     it "should allow specification of whether links should be managed" do
-        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :links => :manage).links.should == :manage
+        Puppet::FileServing::Base.new("/module/dir/file", :links => :manage).links.should == :manage
+    end
+
+    it "should have a :source attribute" do
+        file = Puppet::FileServing::Base.new("/module/dir/file")
+        file.should respond_to(:source)
+        file.should respond_to(:source=)
     end
 
     it "should consider :ignore links equivalent to :manage links" do
-        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :links => :ignore).links.should == :manage
+        Puppet::FileServing::Base.new("/module/dir/file", :links => :ignore).links.should == :manage
     end
 
     it "should fail if :links is set to anything other than :manage, :follow, or :ignore" do
-        proc { Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :links => :else) }.should raise_error(ArgumentError)
+        proc { Puppet::FileServing::Base.new("/module/dir/file", :links => :else) }.should raise_error(ArgumentError)
+    end
+
+    it "should allow links values to be set as strings" do
+        Puppet::FileServing::Base.new("/module/dir/file", :links => "follow").links.should == :follow
     end
 
     it "should default to :manage for :links" do
-        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file").links.should == :manage
+        Puppet::FileServing::Base.new("/module/dir/file").links.should == :manage
     end
 
     it "should allow specification of a path" do
         FileTest.stubs(:exists?).returns(true)
-        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :path => "/my/file").path.should == "/my/file"
+        Puppet::FileServing::Base.new("/module/dir/file", :path => "/my/file").path.should == "/my/file"
     end
 
     it "should allow specification of a relative path" do
         FileTest.stubs(:exists?).returns(true)
-        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :relative_path => "my/file").relative_path.should == "my/file"
+        Puppet::FileServing::Base.new("/module/dir/file", :relative_path => "my/file").relative_path.should == "my/file"
     end
 
     it "should have a means of determining if the file exists" do
-        Puppet::FileServing::FileBase.new("blah").should respond_to(:exist?)
+        Puppet::FileServing::Base.new("/blah").should respond_to(:exist?)
     end
 
     it "should correctly indicate if the file is present" do
         File.expects(:lstat).with("/my/file").returns(mock("stat"))
-        Puppet::FileServing::FileBase.new("blah", :path => "/my/file").exist?.should be_true
+        Puppet::FileServing::Base.new("/my/file").exist?.should be_true
     end
 
-    it "should correctly indicate if the file is asbsent" do
+    it "should correctly indicate if the file is absent" do
         File.expects(:lstat).with("/my/file").raises RuntimeError
-        Puppet::FileServing::FileBase.new("blah", :path => "/my/file").exist?.should be_false
-    end
-
-    describe "when setting the base path" do
-        before do
-            @file = Puppet::FileServing::FileBase.new("puppet://host/module/dir/file")
-        end
-
-        it "should require that the base path be fully qualified" do
-            FileTest.stubs(:exists?).returns(true)
-            proc { @file.path = "unqualified/file" }.should raise_error(ArgumentError)
-        end
+        Puppet::FileServing::Base.new("/my/file").exist?.should be_false
     end
 
     describe "when setting the relative path" do
         it "should require that the relative path be unqualified" do
-            @file = Puppet::FileServing::FileBase.new("puppet://host/module/dir/file")
+            @file = Puppet::FileServing::Base.new("/module/dir/file")
             FileTest.stubs(:exists?).returns(true)
             proc { @file.relative_path = "/qualified/file" }.should raise_error(ArgumentError)
         end
@@ -70,7 +73,7 @@ describe Puppet::FileServing::FileBase do
 
     describe "when determining the full file path" do
         before do
-            @file = Puppet::FileServing::FileBase.new("mykey", :path => "/this/file")
+            @file = Puppet::FileServing::Base.new("/this/file")
         end
 
         it "should return the path if there is no relative path" do
@@ -82,20 +85,25 @@ describe Puppet::FileServing::FileBase do
             @file.full_path.should == "/this/file"
         end
 
+        it "should return the path if the relative_path is set to '.'" do
+            @file.relative_path = "."
+            @file.full_path.should == "/this/file"
+        end
+
         it "should return the path joined with the relative path if there is a relative path and it is not set to '/' or ''" do
             @file.relative_path = "not/qualified"
             @file.full_path.should == "/this/file/not/qualified"
         end
 
-        it "should should fail if there is no path set" do
-            @file = Puppet::FileServing::FileBase.new("not/qualified")
-            proc { @file.full_path }.should raise_error(ArgumentError)
+        it "should strip extra slashes" do
+            file = Puppet::FileServing::Base.new("//this//file")
+            file.full_path.should == "/this/file"
         end
     end
 
     describe "when stat'ing files" do
         before do
-            @file = Puppet::FileServing::FileBase.new("mykey", :path => "/this/file")
+            @file = Puppet::FileServing::Base.new("/this/file")
         end
 
         it "should stat the file's full path" do

data/spec/unit/file_serving/configuration.rb

@@ -15,12 +15,12 @@ describe Puppet::FileServing::Configuration do
 
     it "should have a method for removing the current configuration instance" do
         old = Puppet::FileServing::Configuration.create
-        Puppet::FileServing::Configuration.clear_cache
+        Puppet::Util::Cacher.expire
         Puppet::FileServing::Configuration.create.should_not equal(old)
     end
 
     after do
-        Puppet::FileServing::Configuration.clear_cache
+        Puppet::Util::Cacher.expire
     end
 end
 
@@ -28,14 +28,15 @@ 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::FileServing::Configuration.clear_cache
+        Puppet::Util::Cacher.expire
     end
 
-    describe Puppet::FileServing::Configuration, " when initializing" do
+    describe "when initializing" do
 
         it "should work without a configuration file" do
             FileTest.stubs(:exists?).with(@path).returns(false)
@@ -55,7 +56,7 @@ describe Puppet::FileServing::Configuration do
         end
     end
 
-    describe Puppet::FileServing::Configuration, " when parsing the configuration file" do
+    describe "when parsing the configuration file" do
 
         before do
             FileTest.stubs(:exists?).with(@path).returns(true)
@@ -93,132 +94,142 @@ describe Puppet::FileServing::Configuration do
             config.send(:readconfig, false)
             config.mounted?("one").should be_true
         end
-    end
-
-    describe Puppet::FileServing::Configuration, " when finding files" do
 
-        before do
-            @parser = mock 'parser'
-            @parser.stubs(:changed?).returns true
-            FileTest.stubs(:exists?).with(@path).returns(true)
-            Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+        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
 
-            @mount1 = stub 'mount', :name => "one"
-            @mounts = {"one" => @mount1}
+        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'
+            Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
+            modules.expects(:allow).with('*')
 
-            Facter.stubs(:value).with("hostname").returns("whatever")
+            plugins = stub 'plugins'
+            Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
+            plugins.expects(:allow).with('*')
 
-            @config = Puppet::FileServing::Configuration.create
+            Puppet::FileServing::Configuration.create
         end
 
-        it "should fail if the uri does not match a leading slash followed by a valid mount name" do
-            @parser.expects(:parse).returns(@mounts)
-            proc { @config.file_path("something") }.should raise_error(ArgumentError)
+        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
 
-        it "should use the first term after the first slash for the mount name" do
-            @parser.expects(:parse).returns(@mounts)
-            FileTest.stubs(:exists?).returns(true)
-            @mount1.expects(:file)
-            @config.file_path("/one")
+    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 remainder of the URI after the mount name as the file name" do
-            @parser.expects(:parse).returns(@mounts)
-            @mount1.expects(:file).with("something/else", {})
-            FileTest.stubs(:exists?).returns(true)
-            @config.file_path("/one/something/else")
-        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 treat a bare name as a mount and no relative file" do
-            @parser.expects(:parse).returns(@mounts)
-            @mount1.expects(:file).with(nil, {})
-            FileTest.stubs(:exists?).returns(true)
-            @config.file_path("/one")
-        end
+            mod = mock 'module'
+            env = mock 'environment'
+            env.expects(:module).with("foo").returns mod
+            mount = mock 'mount'
 
-        it "should treat a name with a trailing slash equivalently to a name with no trailing slash" do
-            @parser.expects(:parse).returns(@mounts)
-            @mount1.expects(:file).with(nil, {})
-            FileTest.stubs(:exists?).returns(true)
-            @config.file_path("/one/")
+            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 the mount cannot be found" do
-            @parser.expects(:changed?).returns(true)
-            @parser.expects(:parse).returns({})
-            @config.file_path("/one/something").should be_nil
-        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
 
-        it "should return nil if the mount does not contain the file" do
-            @parser.expects(:parse).returns(@mounts)
-            @mount1.expects(:file).with("something/else", {}).returns(nil)
-            @config.file_path("/one/something/else").should be_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.stubs(:find_mount)
 
-        it "should return the fully qualified path if the mount exists" do
-            @parser.expects(:parse).returns(@mounts)
-            @mount1.expects(:file).with("something/else", {}).returns("/full/path")
-            @config.file_path("/one/something/else").should == "/full/path"
+            @request = stub 'request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => mock("env")
         end
 
-        it "should reparse the configuration file when it has changed" do
-            @mount1.stubs(:file).returns("whatever")
-            @parser.expects(:changed?).returns(true)
-            @parser.expects(:parse).returns(@mounts)
-            FileTest.stubs(:exists?).returns(true)
-            @config.file_path("/one/something")
+        it "should reread the configuration" do
+            @config.expects(:readconfig)
 
-            @parser.expects(:changed?).returns(true)
-            @parser.expects(:parse).returns({})
-            @config.file_path("/one/something").should be_nil
+            @config.split_path(@request)
         end
-    end
 
-    describe Puppet::FileServing::Configuration, " when checking authorization" do
+        it "should treat the first field of the URI path as the mount name" do
+            @config.expects(:find_mount).with { |name, node| name == "foo" }
 
-        before do
-            @parser = mock 'parser'
-            @parser.stubs(:changed?).returns true
-            FileTest.stubs(:exists?).with(@path).returns(true)
-            Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+            @config.split_path(@request)
+        end
 
-            @mount1 = stub 'mount', :name => "one"
-            @mounts = {"one" => @mount1}
-            @parser.stubs(:parse).returns(@mounts)
+        it "should fail if the mount name is not alpha-numeric" do
+            @request.expects(:key).returns "foo&bar/asdf"
 
-            Facter.stubs(:value).with("hostname").returns("whatever")
+            lambda { @config.split_path(@request) }.should raise_error(ArgumentError)
+        end
 
-            @config = Puppet::FileServing::Configuration.create
+        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 return false if the mount cannot be found" do
-            @config.authorized?("/nope/my/file").should be_false
+        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 use the mount to determine authorization" do
-            @mount1.expects(:allowed?)
-            @config.authorized?("/one/my/file")
+        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 pass the client's name to the mount if provided" do
-            @mount1.expects(:allowed?).with("myhost", nil)
-            @config.authorized?("/one/my/file", :node => "myhost")
+        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 pass the client's IP to the mount if provided" do
-            @mount1.expects(:allowed?).with("myhost", "myip")
-            @config.authorized?("/one/my/file", :node => "myhost", :ipaddress => "myip")
+        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 true if the mount allows the client" do
-            @mount1.expects(:allowed?).returns(true)
-            @config.authorized?("/one/my/file").should be_true
+        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 return false if the mount denies the client"  do
-            @mount1.expects(:allowed?).returns(false)
-            @config.authorized?("/one/my/file").should be_false
+        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