path: root/spec/unit/util/settings/file_setting_spec.rb

#!/usr/bin/env ruby

require File.dirname(__FILE__) + '/../../../spec_helper'

require 'puppet/util/settings'
require 'puppet/util/settings/file_setting'

describe Puppet::Util::Settings::FileSetting do
    FileSetting = Puppet::Util::Settings::FileSetting

    before do
        @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
    end

    describe "when determining whether the service user should be used" do
        before do
            @settings = mock 'settings'
            @settings.stubs(:[]).with(:mkusers).returns false
            @settings.stubs(:service_user_available?).returns true
        end

        it "should be true if the service user is available" do
            @settings.expects(:service_user_available?).returns true
            setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
            setting.should be_use_service_user
        end

        it "should be true if 'mkusers' is set" do
            @settings.expects(:[]).with(:mkusers).returns true
            setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
            setting.should be_use_service_user
        end

        it "should be false if the service user is not available and 'mkusers' is unset" do
            setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
            setting.should be_use_service_user
        end
    end

    describe "when setting the owner" do
        it "should allow the file to be owned by root" do
            root_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting") }
            root_owner.should_not raise_error
        end

        it "should allow the file to be owned by the service user" do
            service_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "service", :desc => "a setting") }
            service_owner.should_not raise_error
        end

        it "should allow the ownership of the file to be unspecified" do
            no_owner = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
            no_owner.should_not raise_error
        end

        it "should not allow other owners" do
            invalid_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "invalid", :desc => "a setting") }
            invalid_owner.should raise_error(FileSetting::SettingError)
        end
    end

    describe "when reading the owner" do
        it "should be root when the setting specifies root" do
            setting = FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting") 
            setting.owner.should == "root"
        end

        it "should be the owner of the service when the setting specifies service and the service user should be used" do
            settings = mock("settings")
            settings.stubs(:[]).returns "the_service"

            setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
            setting.expects(:use_service_user?).returns true
            setting.owner.should == "the_service"
        end

        it "should be the root when the setting specifies service and the service user should not be used" do
            settings = mock("settings")
            settings.stubs(:[]).returns "the_service"

            setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
            setting.expects(:use_service_user?).returns false
            setting.owner.should == "root"
        end

        it "should be nil when the owner is unspecified" do
            FileSetting.new(:settings => mock("settings"), :desc => "a setting").owner.should be_nil
        end
    end

    describe "when setting the group" do
        it "should allow the group to be service" do
            service_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "service", :desc => "a setting") }
            service_group.should_not raise_error
        end

        it "should allow the group to be unspecified" do
            no_group = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
            no_group.should_not raise_error
        end

        it "should not allow invalid groups" do
            invalid_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "invalid", :desc => "a setting") }
            invalid_group.should raise_error(FileSetting::SettingError)
        end
    end

    describe "when reading the group" do
        it "should be service when the setting specifies service" do
            setting = FileSetting.new(:settings => mock("settings", :[] => "the_service"), :group => "service", :desc => "a setting")
            setting.group.should == "the_service"
        end

        it "should be nil when the group is unspecified" do
            FileSetting.new(:settings => mock("settings"), :desc => "a setting").group.should be_nil
        end
    end

    it "should be able to be converted into a resource" do
        FileSetting.new(:settings => mock("settings"), :desc => "eh").should respond_to(:to_resource)
    end

    describe "when being converted to a resource" do
        before do
            @settings = mock 'settings'
            @file = Puppet::Util::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
            @settings.stubs(:value).with(:mydir).returns @basepath
        end

        it "should skip files that cannot determine their types" do
            @file.expects(:type).returns nil
            @file.to_resource.should be_nil
        end

        it "should skip non-existent files if 'create_files' is not enabled" do
            @file.expects(:create_files?).returns false
            @file.expects(:type).returns :file
            File.expects(:exist?).with(@basepath).returns false
            @file.to_resource.should be_nil
        end

        it "should manage existent files even if 'create_files' is not enabled" do
            @file.expects(:create_files?).returns false
            @file.expects(:type).returns :file
            File.expects(:exist?).with(@basepath).returns true
            @file.to_resource.should be_instance_of(Puppet::Resource)
        end

        describe "on POSIX systems" do
            confine "no /dev on Microsoft Windows" => Puppet.features.posix?

            it "should skip files in /dev" do
                @settings.stubs(:value).with(:mydir).returns "/dev/file"
                @file.to_resource.should be_nil
            end
        end

        it "should skip files whose paths are not strings" do
            @settings.stubs(:value).with(:mydir).returns :foo
            @file.to_resource.should be_nil
        end

        it "should return a file resource with the path set appropriately" do
            resource = @file.to_resource
            resource.type.should == "File"
            resource.title.should == @basepath
        end

        it "should fully qualified returned files if necessary (#795)" do
            @settings.stubs(:value).with(:mydir).returns "myfile"
            @file.to_resource.title.should == File.join(Dir.getwd, "myfile")
        end

        it "should set the mode on the file if a mode is provided" do
            @file.mode = 0755

            @file.to_resource[:mode].should == 0755
        end

        it "should not set the mode on a the file if manage_internal_file_permissions is disabled" do
            Puppet[:manage_internal_file_permissions] = false

            @file.stubs(:mode).returns(0755)

            @file.to_resource[:mode].should == nil
        end

        it "should set the owner if running as root and the owner is provided" do
            Puppet.features.expects(:root?).returns true
            @file.stubs(:owner).returns "foo"
            @file.to_resource[:owner].should == "foo"
        end

        it "should not set the owner if manage_internal_file_permissions is disabled" do
            Puppet[:manage_internal_file_permissions] = false
            Puppet.features.stubs(:root?).returns true
            @file.stubs(:owner).returns "foo"

            @file.to_resource[:owner].should == nil
        end

        it "should set the group if running as root and the group is provided" do
            Puppet.features.expects(:root?).returns true
            @file.stubs(:group).returns "foo"
            @file.to_resource[:group].should == "foo"
        end

        it "should not set the group if manage_internal_file_permissions is disabled" do
            Puppet[:manage_internal_file_permissions] = false
            Puppet.features.stubs(:root?).returns true
            @file.stubs(:group).returns "foo"

            @file.to_resource[:group].should == nil
        end


        it "should not set owner if not running as root" do
            Puppet.features.expects(:root?).returns false
            @file.stubs(:owner).returns "foo"
            @file.to_resource[:owner].should be_nil
        end

        it "should not set group if not running as root" do
            Puppet.features.expects(:root?).returns false
            @file.stubs(:group).returns "foo"
            @file.to_resource[:group].should be_nil
        end

        it "should set :ensure to the file type" do
            @file.expects(:type).returns :directory
            @file.to_resource[:ensure].should == :directory
        end

        it "should set the loglevel to :debug" do
            @file.to_resource[:loglevel].should == :debug
        end

        it "should set the backup to false" do
            @file.to_resource[:backup].should be_false
        end

        it "should tag the resource with the settings section" do
            @file.expects(:section).returns "mysect"
            @file.to_resource.should be_tagged("mysect")
        end

        it "should tag the resource with the setting name" do
            @file.to_resource.should be_tagged("mydir")
        end

        it "should tag the resource with 'settings'" do
            @file.to_resource.should be_tagged("settings")
        end
    end
end