puppet 0.25.5 → 2.6.0

data/spec/unit/file_serving/base_spec.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_serving/base'
+
+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::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::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::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::Base.new("/module/dir/file").links.should == :manage
+  end
+
+  it "should allow specification of a path" do
+    FileTest.stubs(:exists?).returns(true)
+    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::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::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::Base.new("/my/file").exist?.should be_true
+  end
+
+  it "should correctly indicate if the file is absent" do
+    File.expects(:lstat).with("/my/file").raises RuntimeError
+    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::Base.new("/module/dir/file")
+      FileTest.stubs(:exists?).returns(true)
+      proc { @file.relative_path = "/qualified/file" }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "when determining the full file path" do
+    before do
+      @file = Puppet::FileServing::Base.new("/this/file")
+    end
+
+    it "should return the path if there is no relative path" 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 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 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::Base.new("/this/file")
+    end
+
+    it "should stat the file's full path" do
+      @file.stubs(:full_path).returns("/this/file")
+      File.expects(:lstat).with("/this/file").returns stub("stat", :ftype => "file")
+      @file.stat
+    end
+
+    it "should fail if the file does not exist" do
+      @file.stubs(:full_path).returns("/this/file")
+      File.expects(:lstat).with("/this/file").raises(Errno::ENOENT)
+      proc { @file.stat }.should raise_error(Errno::ENOENT)
+    end
+
+    it "should use :lstat if :links is set to :manage" do
+      File.expects(:lstat).with("/this/file").returns stub("stat", :ftype => "file")
+      @file.stat
+    end
+
+    it "should use :stat if :links is set to :follow" do
+      File.expects(:stat).with("/this/file").returns stub("stat", :ftype => "file")
+      @file.links = :follow
+      @file.stat
+    end
+  end
+end

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/file_serving/configuration/parser'
+
+describe Puppet::FileServing::Configuration::Parser do
+  it "should subclass the LoadedFile class" do
+    Puppet::FileServing::Configuration::Parser.superclass.should equal(Puppet::Util::LoadedFile)
+  end
+end
+
+
+module FSConfigurationParserTesting
+  def mock_file_content(content)
+    # We want an array, but we actually want our carriage returns on all of it.
+    lines = content.split("\n").collect { |l| l + "\n" }
+    @filehandle.stubs(:each).multiple_yields(*lines)
+  end
+end
+
+describe Puppet::FileServing::Configuration::Parser do
+  before :each do
+    @path = "/my/config.conf"
+    FileTest.stubs(:exists?).with(@path).returns(true)
+    FileTest.stubs(:readable?).with(@path).returns(true)
+    @filehandle = mock 'filehandle'
+    File.expects(:open).with(@path).yields(@filehandle)
+    @parser = Puppet::FileServing::Configuration::Parser.new(@path)
+  end
+
+  describe Puppet::FileServing::Configuration::Parser, " when parsing" do
+    include FSConfigurationParserTesting
+
+    it "should allow comments" do
+      @filehandle.expects(:each).yields("# this is a comment\n")
+      proc { @parser.parse }.should_not raise_error
+    end
+
+    it "should allow blank lines" do
+      @filehandle.expects(:each).yields("\n")
+      proc { @parser.parse }.should_not raise_error
+    end
+
+    it "should create a new mount for each section in the configuration" do
+      mount1 = mock 'one', :validate => true
+      mount2 = mock 'two', :validate => true
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+      Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
+      mock_file_content "[one]\n[two]\n"
+      @parser.parse
+    end
+
+    # This test is almost the exact same as the previous one.
+    it "should return a hash of the created mounts" do
+      mount1 = mock 'one', :validate => true
+      mount2 = mock 'two', :validate => true
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+      Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
+      mock_file_content "[one]\n[two]\n"
+
+      result = @parser.parse
+      result["one"].should equal(mount1)
+      result["two"].should equal(mount2)
+    end
+
+    it "should only allow mount names that are alphanumeric plus dashes" do
+      mock_file_content "[a*b]\n"
+      proc { @parser.parse }.should raise_error(ArgumentError)
+    end
+
+    it "should fail if the value for path/allow/deny starts with an equals sign" do
+      mock_file_content "[one]\npath = /testing"
+      proc { @parser.parse }.should raise_error(ArgumentError)
+    end
+
+    it "should validate each created mount" do
+      mount1 = mock 'one'
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+      mock_file_content "[one]\n"
+
+      mount1.expects(:validate)
+
+      @parser.parse
+    end
+
+    it "should fail if any mount does not pass validation" do
+      mount1 = mock 'one'
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+      mock_file_content "[one]\n"
+
+      mount1.expects(:validate).raises RuntimeError
+
+      lambda { @parser.parse }.should raise_error(RuntimeError)
+    end
+  end
+
+  describe Puppet::FileServing::Configuration::Parser, " when parsing mount attributes" do
+    include FSConfigurationParserTesting
+
+    before do
+      @mount = stub 'testmount', :name => "one", :validate => true
+      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(@mount)
+      @parser.stubs(:add_modules_mount)
+    end
+
+    it "should set the mount path to the path attribute from that section" do
+      mock_file_content "[one]\npath /some/path\n"
+
+      @mount.expects(:path=).with("/some/path")
+      @parser.parse
+    end
+
+    it "should tell the mount to allow any allow values from the section" do
+      mock_file_content "[one]\nallow something\n"
+
+      @mount.expects(:info)
+      @mount.expects(:allow).with("something")
+      @parser.parse
+    end
+
+    it "should tell the mount to deny any deny values from the section" do
+      mock_file_content "[one]\ndeny something\n"
+
+      @mount.expects(:info)
+      @mount.expects(:deny).with("something")
+      @parser.parse
+    end
+
+    it "should fail on any attributes other than path, allow, and deny" do
+      mock_file_content "[one]\ndo something\n"
+
+      proc { @parser.parse }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe Puppet::FileServing::Configuration::Parser, " when parsing the modules mount" do
+    include FSConfigurationParserTesting
+
+    before do
+      @mount = stub 'modulesmount', :name => "modules", :validate => true
+    end
+
+    it "should create an instance of the Modules Mount class" do
+      mock_file_content "[modules]\n"
+
+      Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns @mount
+      @parser.parse
+    end
+
+    it "should warn if a path is set" do
+      mock_file_content "[modules]\npath /some/path\n"
+      Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns(@mount)
+
+      Puppet.expects(:warning)
+      @parser.parse
+    end
+  end
+
+  describe Puppet::FileServing::Configuration::Parser, " when parsing the plugins mount" do
+    include FSConfigurationParserTesting
+
+    before do
+      @mount = stub 'pluginsmount', :name => "plugins", :validate => true
+    end
+
+    it "should create an instance of the Plugins Mount class" do
+      mock_file_content "[plugins]\n"
+
+      Puppet::FileServing::Mount::Plugins.expects(:new).with("plugins").returns @mount
+      @parser.parse
+    end
+
+    it "should warn if a path is set" do
+      mock_file_content "[plugins]\npath /some/path\n"
+
+      Puppet.expects(:warning)
+      @parser.parse
+    end
+  end
+end

data/spec/unit/file_serving/configuration_spec.rb

@@ -0,0 +1,249 @@
+#!/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