puppet 0.24.6 → 0.24.7

data/spec/unit/file_serving/indirection_hooks.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-18.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_serving/indirection_hooks'
+
+describe Puppet::FileServing::IndirectionHooks do
+    before do
+        @object = Object.new
+        @object.extend(Puppet::FileServing::IndirectionHooks)
+
+        @request = stub 'request', :key => "http://myhost/blah", :options => {:node => "whatever"}
+    end
+
+    describe "when being used to select termini" do
+        it "should escape the key before parsing" do
+            uri = stub 'uri', :scheme => "puppet", :host => "blah", :path => "/something"
+            URI.expects(:escape).with("http://myhost/blah").returns("escaped_blah")
+            URI.expects(:parse).with("escaped_blah").returns(uri)
+            @object.select_terminus(@request)
+        end
+
+        it "should use the URI class to parse the key" do
+            uri = stub 'uri', :scheme => "puppet", :host => "blah", :path => "/something"
+            URI.expects(:parse).with("http://myhost/blah").returns(uri)
+            @object.select_terminus @request
+        end
+
+        it "should choose :rest when the protocol is 'puppet'" do
+            @request.stubs(:key).returns "puppet://host/module/file"
+            @object.select_terminus(@request).should == :rest
+        end
+
+        it "should choose :file_server when the protocol is 'puppetmounts' and the mount name is not 'modules'" do
+            modules = mock 'modules'
+            @object.stubs(:terminus).with(:modules).returns(modules)
+            modules.stubs(:find_module).returns(nil)
+
+            @request.stubs(:key).returns "puppetmounts://host/notmodules/file"
+
+            @object.select_terminus(@request).should == :file_server
+        end
+
+        it "should choose :file_server when no server name is provided, the process name is 'puppet', and the mount name is not 'modules'" do
+            modules = mock 'modules'
+            @object.stubs(:terminus).with(:modules).returns(modules)
+            modules.stubs(:find_module).returns(nil)
+
+            Puppet.settings.expects(:value).with(:name).returns("puppet")
+            @request.stubs(:key).returns "puppet:///notmodules/file"
+            @object.select_terminus(@request).should == :file_server
+        end
+
+        it "should choose :modules if it would normally choose :file_server but the mount name is 'modules'" do
+            @request.stubs(:key).returns "puppetmounts://host/modules/mymod/file"
+            @object.select_terminus(@request).should == :modules
+        end
+
+        it "should choose :modules if it would normally choose :file_server but a module exists with the mount name" do
+            modules = mock 'modules'
+
+            @object.expects(:terminus).with(:modules).returns(modules)
+            modules.expects(:find_module).with("mymod", @request.options[:node]).returns(:thing)
+
+            @request.stubs(:key).returns "puppetmounts://host/mymod/file"
+            @object.select_terminus(@request).should == :modules
+        end
+
+        it "should choose :rest when no server name is provided and the process name is not 'puppet'" do
+            Puppet.settings.expects(:value).with(:name).returns("puppetd")
+            @request.stubs(:key).returns "puppet:///module/file"
+            @object.select_terminus(@request).should == :rest
+        end
+
+        it "should choose :file when the protocol is 'file'" do
+            @request.stubs(:key).returns "file://host/module/file"
+            @object.select_terminus(@request).should == :file
+        end
+
+        it "should choose :file when the URI is a normal path name" do
+            @request.stubs(:key).returns "/module/file"
+            @object.select_terminus(@request).should == :file
+        end
+
+        # This is so that we only choose modules over mounts, not file
+        it "should choose :file when the protocol is 'file' and the fully qualified path starts with '/modules'" do
+            @request.stubs(:key).returns "/module/file"
+            @object.select_terminus(@request).should == :file
+        end
+
+        it "should fail when a protocol other than :puppet, :file, or :puppetmounts is used" do
+            @request.stubs(:key).returns "http:///module/file"
+            proc { @object.select_terminus(@request) }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe "when looking for a module whose name matches the mount name" do
+        before do
+            @modules = mock 'modules'
+            @object.stubs(:terminus).with(:modules).returns(@modules)
+
+            @request.stubs(:key).returns "puppetmounts://host/mymod/file"
+        end
+
+        it "should use the modules terminus to look up the module" do
+            @modules.expects(:find_module).with("mymod", @request.options[:node])
+            @object.select_terminus @request
+        end
+
+        it "should pass the node name to the modules terminus" do
+            @modules.expects(:find_module).with("mymod", @request.options[:node])
+            @object.select_terminus @request
+        end
+
+        it "should log a deprecation warning if a module is found" do
+            @modules.expects(:find_module).with("mymod", @request.options[:node]).returns(:something)
+            Puppet.expects(:warning)
+            @object.select_terminus @request
+        end
+    end
+end

data/spec/unit/file_serving/metadata.rb

@@ -0,0 +1,187 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_serving/metadata'
+
+describe Puppet::FileServing::Metadata do
+    it "should should be a subclass of FileBase" do
+        Puppet::FileServing::Metadata.superclass.should equal(Puppet::FileServing::FileBase)
+    end
+
+    it "should indirect file_metadata" do
+        Puppet::FileServing::Metadata.indirection.name.should == :file_metadata
+    end
+
+    it "should should include the IndirectionHooks module in its indirection" do
+        Puppet::FileServing::Metadata.indirection.metaclass.included_modules.should include(Puppet::FileServing::IndirectionHooks)
+    end
+end
+
+describe Puppet::FileServing::Metadata, " when finding the file to use for setting attributes" do
+    before do
+        @metadata = Puppet::FileServing::Metadata.new("my/path")
+
+        @full = "/base/path/my/path"
+
+        @metadata.path = @full
+
+        # Use a link because it's easier to test -- no checksumming
+        @stat = stub "stat", :uid => 10, :gid => 20, :mode => 0755, :ftype => "link"
+    end
+
+    it "should accept a base path path to which the file should be relative" do
+        File.expects(:lstat).with(@full).returns @stat
+        File.expects(:readlink).with(@full).returns "/what/ever"
+        @metadata.collect_attributes
+    end
+
+    it "should use the set base path if one is not provided" do
+        File.expects(:lstat).with(@full).returns @stat
+        File.expects(:readlink).with(@full).returns "/what/ever"
+        @metadata.collect_attributes()
+    end
+
+    it "should fail if a base path is neither set nor provided" do
+        proc { @metadata.collect_attributes() }.should raise_error(Errno::ENOENT)
+    end
+
+    it "should raise an exception if the file does not exist" do
+        File.expects(:lstat).with(@full).raises(Errno::ENOENT)
+        proc { @metadata.collect_attributes()}.should raise_error(Errno::ENOENT)
+    end
+end
+
+describe Puppet::FileServing::Metadata, " when collecting attributes" do
+    before do
+        @path = "/my/file"
+        # Use a real file mode, so we can validate the masking is done.
+        @stat = stub 'stat', :uid => 10, :gid => 20, :mode => 33261, :ftype => "file"
+        File.stubs(:lstat).returns(@stat)
+        @checksum = Digest::MD5.hexdigest("some content\n")
+        @metadata = Puppet::FileServing::Metadata.new("file", :path => "/my/file")
+        @metadata.stubs(:md5_file).returns(@checksum)
+        @metadata.collect_attributes
+    end
+
+    it "should be able to produce xmlrpc-style attribute information" do
+        @metadata.should respond_to(:attributes_with_tabs)
+    end
+
+    # LAK:FIXME This should actually change at some point
+    it "should set the owner by id" do
+        @metadata.owner.should be_instance_of(Fixnum)
+    end
+
+    # LAK:FIXME This should actually change at some point
+    it "should set the group by id" do
+        @metadata.group.should be_instance_of(Fixnum)
+    end
+
+    it "should set the owner to the file's current owner" do
+        @metadata.owner.should == 10
+    end
+
+    it "should set the group to the file's current group" do
+        @metadata.group.should == 20
+    end
+
+    it "should set the mode to the file's masked mode" do
+        @metadata.mode.should == 0755
+    end
+
+    it "should set the checksum to the file's current checksum" do
+        @metadata.checksum.should == "{md5}" + @checksum
+    end
+
+    describe "when managing files" do
+        it "should default to a checksum of type MD5" do
+            @metadata.checksum.should == "{md5}" + @checksum
+        end
+
+        it "should give a mtime checksum when checksum_type is set" do
+            time = Time.now
+            @metadata.checksum_type = "mtime"
+            @metadata.expects(:mtime_file).returns(@time)
+            @metadata.collect_attributes
+            @metadata.checksum.should == "{mtime}" + @time.to_s
+        end
+
+        it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
+            @metadata.attributes_with_tabs.should == "#{0755.to_s}\tfile\t10\t20\t{md5}#{@checksum}"
+        end
+    end
+
+    describe "when managing directories" do
+        before do
+            @stat.stubs(:ftype).returns("directory")
+            @time = Time.now
+            @metadata.expects(:ctime_file).returns(@time)
+        end
+
+        it "should only use checksums of type 'ctime' for directories" do
+            @metadata.collect_attributes
+            @metadata.checksum.should == "{ctime}" + @time.to_s
+        end
+
+        it "should only use checksums of type 'ctime' for directories even if checksum_type set" do
+            @metadata.checksum_type = "mtime"
+            @metadata.expects(:mtime_file).never
+            @metadata.collect_attributes
+            @metadata.checksum.should == "{ctime}" + @time.to_s
+        end
+
+        it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
+            @metadata.collect_attributes
+            @metadata.attributes_with_tabs.should == "#{0755.to_s}\tdirectory\t10\t20\t{ctime}#{@time.to_s}"
+        end
+    end
+
+    describe "when managing links" do
+        before do
+            @stat.stubs(:ftype).returns("link")
+            File.expects(:readlink).with("/my/file").returns("/path/to/link")
+            @metadata.collect_attributes
+        end
+
+        it "should read links instead of returning their checksums" do
+            @metadata.destination.should == "/path/to/link"
+        end
+
+        it "should produce tab-separated mode, type, owner, group, and destination for xmlrpc" do
+            @metadata.attributes_with_tabs.should == "#{0755.to_s}\tlink\t10\t20\t/path/to/link"
+        end
+    end
+end
+
+describe Puppet::FileServing::Metadata, " when pointing to a link" do
+    it "should store the destination of the link in :destination if links are :manage" do
+        file = Puppet::FileServing::Metadata.new("mykey", :links => :manage, :path => "/base/path/my/file")
+
+        File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
+        File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
+
+        file.collect_attributes
+        file.destination.should == "/some/other/path"
+    end
+
+    it "should not collect the checksum" do
+        file = Puppet::FileServing::Metadata.new("my/file", :links => :manage, :path => "/base/path/my/file")
+
+        File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
+        File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
+
+        file.collect_attributes
+        file.checksum.should be_nil
+    end
+end
+
+describe Puppet::FileServing::Metadata, " when converting from yaml" do
+    # LAK:FIXME This isn't in the right place, but we need some kind of
+    # control somewhere that requires that all REST connections only pull
+    # from the file-server, thus guaranteeing they go through our authorization
+    # hook.
+    it "should set the URI scheme to 'puppetmounts'" do
+        pending "We need to figure out where this should be"
+    end
+end

data/spec/unit/file_serving/mount.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/file_serving/mount'
+
+module FileServingMountTesting
+    def stub_facter(hostname)
+        Facter.stubs(:value).with("hostname").returns(hostname.sub(/\..+/, ''))
+        Facter.stubs(:value).with("domain").returns(hostname.sub(/^[^.]+\./, ''))
+    end
+end
+
+describe Puppet::FileServing::Mount do
+    it "should provide a method for clearing its cached host information" do
+        Puppet::FileServing::Mount.new("whatever").send(:localmap)
+        Puppet::FileServing::Mount.clear_cache
+        Puppet::FileServing::Mount.send(:class_variable_get, "@@localmap").should be_nil
+    end
+end
+
+describe Puppet::FileServing::Mount, " when initializing" do
+    it "should fail on non-alphanumeric name" do
+        proc { Puppet::FileServing::Mount.new("non alpha") }.should raise_error(ArgumentError)
+    end
+
+    it "should allow dashes in its name" do
+        Puppet::FileServing::Mount.new("non-alpha").name.should == "non-alpha"
+    end
+
+    it "should allow an optional path" do
+        Puppet::FileServing::Mount.new("name", "/").path.should == "/"
+    end
+end
+
+describe Puppet::FileServing::Mount, " when setting the path" do
+    before do
+        @mount = Puppet::FileServing::Mount.new("test")
+        @dir = "/this/path/does/not/exist"
+    end
+
+    it "should fail if the path is not a directory" do
+        FileTest.expects(:directory?).returns(false)
+        proc { @mount.path = @dir }.should raise_error(ArgumentError)
+    end
+
+    it "should fail if the path is not readable" do
+        FileTest.expects(:directory?).returns(true)
+        FileTest.expects(:readable?).returns(false)
+        proc { @mount.path = @dir }.should raise_error(ArgumentError)
+    end
+end
+
+describe Puppet::FileServing::Mount, " when finding files" do
+    include FileServingMountTesting
+
+    before do
+        FileTest.stubs(:directory?).returns(true)
+        FileTest.stubs(:readable?).returns(true)
+        @mount = Puppet::FileServing::Mount.new("test")
+        @host = "host.domain.com"
+    end
+
+    it "should fail if the mount path has not been set" do
+        proc { @mount.file_path("/blah") }.should raise_error(ArgumentError)
+    end
+
+    it "should replace incidences of %h in the path with the client's short name" do
+        @mount.path = "/dir/%h/yay"
+        @mount.path(@host).should == "/dir/host/yay"
+    end
+
+    it "should replace incidences of %H in the path with the client's fully qualified name" do
+        @mount.path = "/dir/%H/yay"
+        @mount.path(@host).should == "/dir/host.domain.com/yay"
+    end
+
+    it "should replace incidences of %d in the path with the client's domain name" do
+        @mount.path = "/dir/%d/yay"
+        @mount.path(@host).should == "/dir/domain.com/yay"
+    end
+
+    it "should perform all necessary replacements" do
+        @mount.path = "/%h/%d/%H"
+        @mount.path(@host).should == "/host/domain.com/host.domain.com"
+    end
+
+    it "should perform replacements on the base path" do
+        @mount.path = "/blah/%h"
+        @mount.file_path("/my/stuff", @host).should == "/blah/host/my/stuff"
+    end
+
+    it "should not perform replacements on the per-file path" do
+        @mount.path = "/blah"
+        @mount.file_path("/%h/stuff", @host).should == "/blah/%h/stuff"
+    end
+
+    it "should look for files relative to its base directory" do
+        @mount.path = "/blah"
+        @mount.file_path("/my/stuff", @host).should == "/blah/my/stuff"
+    end
+
+    it "should use local host information if no client data is provided" do
+        stub_facter("myhost.mydomain.com")
+        @mount.path = "/%h/%d/%H"
+        @mount.path().should == "/myhost/mydomain.com/myhost.mydomain.com"
+    end
+
+    after do
+        Puppet::FileServing::Mount.clear_cache
+    end
+end
+
+describe Puppet::FileServing::Mount, " when providing file paths" do
+    include FileServingMountTesting
+
+    before do
+        FileTest.stubs(:exists?).returns(true)
+        FileTest.stubs(:directory?).returns(true)
+        FileTest.stubs(:readable?).returns(true)
+        @mount = Puppet::FileServing::Mount.new("test", "/mount/%h")
+        stub_facter("myhost.mydomain.com")
+        @host = "host.domain.com"
+    end
+
+    it "should return nil if the file is absent" do
+        FileTest.stubs(:exists?).returns(false)
+        @mount.file("/my/path").should be_nil
+    end
+
+    it "should return the file path if the file is absent" do
+        FileTest.stubs(:exists?).with("/my/path").returns(true)
+        @mount.file("/my/path").should == "/mount/myhost/my/path"
+    end
+
+    it "should treat a nil file name as the path to the mount itself" do
+        FileTest.stubs(:exists?).returns(true)
+        @mount.file(nil).should == "/mount/myhost"
+    end
+
+    it "should use the client host name if provided in the options" do
+        @mount.file("/my/path", :node => @host).should == "/mount/host/my/path"
+    end
+end