path: root/spec/unit/file_serving/configuration_spec.rb

#!/usr/bin/env ruby

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
    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 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 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
        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
        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 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

            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

            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.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