puppet 0.25.5 → 2.6.0

data/spec/unit/file_serving/indirection_hooks_spec.rb

@@ -0,0 +1,63 @@
+#!/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 => "mymod/myfile", :options => {:node => "whatever"}, :server => nil, :protocol => nil
+  end
+
+  describe "when being used to select termini" do
+    it "should return :file if the request key is fully qualified" do
+      @request.expects(:key).returns "#{File::SEPARATOR}foo"
+      @object.select_terminus(@request).should == :file
+    end
+
+    it "should return :file if the URI protocol is set to 'file'" do
+      @request.expects(:protocol).returns "file"
+      @object.select_terminus(@request).should == :file
+    end
+
+    it "should fail when a protocol other than :puppet or :file is used" do
+      @request.stubs(:protocol).returns "http"
+      proc { @object.select_terminus(@request) }.should raise_error(ArgumentError)
+    end
+
+    describe "and the protocol is 'puppet'" do
+      before do
+        @request.stubs(:protocol).returns "puppet"
+      end
+
+      it "should choose :rest when a server is specified" do
+        @request.stubs(:protocol).returns "puppet"
+        @request.expects(:server).returns "foo"
+        @object.select_terminus(@request).should == :rest
+      end
+
+      # This is so a given file location works when bootstrapping with no server.
+      it "should choose :rest when the Settings name isn't 'puppet'" do
+        @request.stubs(:protocol).returns "puppet"
+        @request.stubs(:server).returns "foo"
+        Puppet.settings.stubs(:value).with(:name).returns "foo"
+        @object.select_terminus(@request).should == :rest
+      end
+
+      it "should choose :file_server when the settings name is 'puppet' and no server is specified" do
+        modules = mock 'modules'
+
+        @request.expects(:protocol).returns "puppet"
+        @request.expects(:server).returns nil
+        Puppet.settings.expects(:value).with(:name).returns "puppet"
+        @object.select_terminus(@request).should == :file_server
+      end
+    end
+  end
+end

data/spec/unit/file_serving/metadata_spec.rb

@@ -0,0 +1,286 @@
+#!/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 Base" do
+    Puppet::FileServing::Metadata.superclass.should equal(Puppet::FileServing::Base)
+  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.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
+  end
+
+  it "should have a method that triggers attribute collection" do
+    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:collect)
+  end
+
+  it "should support pson serialization" do
+    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson)
+  end
+
+  it "should support to_pson_data_hash" do
+    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson_data_hash)
+  end
+
+  it "should support pson deserialization" do
+    Puppet::FileServing::Metadata.should respond_to(:from_pson)
+  end
+
+  describe "when serializing" do
+    before do
+      @metadata = Puppet::FileServing::Metadata.new("/foo/bar")
+    end
+    it "should perform pson serialization by calling to_pson on it's pson_data_hash" do
+      pdh = mock "data hash"
+      pdh_as_pson = mock "data as pson"
+      @metadata.expects(:to_pson_data_hash).returns pdh
+      pdh.expects(:to_pson).returns pdh_as_pson
+      @metadata.to_pson.should == pdh_as_pson
+    end
+
+    it "should serialize as FileMetadata" do
+      @metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
+    end
+
+    it "the data should include the path, relative_path, links, owner, group, mode, checksum, type, and destination" do
+      @metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
+    end
+
+    it "should pass the path in the hash verbatum" do
+      @metadata.to_pson_data_hash['data']['path'] == @metadata.path
+    end
+
+    it "should pass the relative_path in the hash verbatum" do
+      @metadata.to_pson_data_hash['data']['relative_path'] == @metadata.relative_path
+    end
+
+    it "should pass the links in the hash verbatum" do
+      @metadata.to_pson_data_hash['data']['links'] == @metadata.links
+    end
+
+    it "should pass the path owner in the hash verbatum" do
+      @metadata.to_pson_data_hash['data']['owner'] == @metadata.owner
+    end
+
+    it "should pass the group in the hash verbatum" do
+      @metadata.to_pson_data_hash['data']['group'] == @metadata.group
+    end
+
+    it "should pass the mode in the hash verbatum" do
+      @metadata.to_pson_data_hash['data']['mode'] == @metadata.mode
+    end
+
+    it "should pass the ftype in the hash verbatum as the 'type'" do
+      @metadata.to_pson_data_hash['data']['type'] == @metadata.ftype
+    end
+
+    it "should pass the destination verbatum" do
+      @metadata.to_pson_data_hash['data']['destination'] == @metadata.destination
+    end
+
+    it "should pass the checksum in the hash as a nested hash" do
+      @metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
+    end
+
+    it "should pass the checksum_type in the hash verbatum as the checksum's type" do
+      @metadata.to_pson_data_hash['data']['checksum']['type'] == @metadata.checksum_type
+    end
+
+    it "should pass the checksum in the hash verbatum as the checksum's value" do
+      @metadata.to_pson_data_hash['data']['checksum']['value'] == @metadata.checksum
+    end
+
+  end
+end
+
+describe Puppet::FileServing::Metadata, " when finding the file to use for setting attributes" do
+  before do
+    @path = "/my/path"
+    @metadata = Puppet::FileServing::Metadata.new(@path)
+
+    # Use a link because it's easier to test -- no checksumming
+    @stat = stub "stat", :uid => 10, :gid => 20, :mode => 0755, :ftype => "link"
+
+    # Not quite.  We don't want to checksum links, but we must because they might be being followed.
+    @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
+    @metadata.stubs(:md5_file).returns(@checksum)           #
+  end
+
+  it "should accept a base path path to which the file should be relative" do
+    File.expects(:lstat).with(@path).returns @stat
+    File.expects(:readlink).with(@path).returns "/what/ever"
+    @metadata.collect
+  end
+
+  it "should use the set base path if one is not provided" do
+    File.expects(:lstat).with(@path).returns @stat
+    File.expects(:readlink).with(@path).returns "/what/ever"
+    @metadata.collect
+  end
+
+  it "should raise an exception if the file does not exist" do
+    File.expects(:lstat).with(@path).raises(Errno::ENOENT)
+    proc { @metadata.collect}.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("/my/file")
+    @metadata.stubs(:md5_file).returns(@checksum)
+    @metadata.collect
+  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
+      @metadata.checksum.should == "{mtime}#{@time}"
+    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
+      @metadata.checksum.should == "{ctime}#{@time}"
+    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
+      @metadata.checksum.should == "{ctime}#{@time}"
+    end
+
+    it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
+      @metadata.collect
+      @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
+
+      @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
+      @file.stubs(:md5_file).returns(@checksum)           #
+    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
+      pending "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
+      @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t/path/to/link"
+    end
+
+    it "should produce tab-separated mode, type, owner, group, checksum, and destination for xmlrpc" do
+      @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t{md5}eb9c2bf0eb63f3a7bc0ea37ef18aeba5\t/path/to/link"
+    end
+  end
+end
+
+describe Puppet::FileServing::Metadata, " when pointing to a link" do
+  describe "when links are managed" do
+    before do
+      @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :manage)
+      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"
+
+      @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
+      @file.stubs(:md5_file).returns(@checksum)           #
+    end
+    it "should store the destination of the link in :destination if links are :manage" do
+      @file.collect
+      @file.destination.should == "/some/other/path"
+    end
+    it "should not collect the checksum if links are :manage" do
+      pending "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
+      @file.collect
+      @file.checksum.should be_nil
+    end
+    it "should collect the checksum if links are :manage" do # see pending note above
+      @file.collect
+      @file.checksum.should == "{md5}#{@checksum}"
+    end
+  end
+
+  describe "when links are followed" do
+    before do
+      @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :follow)
+      File.expects(:stat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
+      File.expects(:readlink).with("/base/path/my/file").never
+      @checksum = Digest::MD5.hexdigest("some content\n")
+      @file.stubs(:md5_file).returns(@checksum)
+    end
+    it "should not store the destination of the link in :destination if links are :follow" do
+      @file.collect
+      @file.destination.should be_nil
+    end
+    it "should collect the checksum if links are :follow" do
+      @file.collect
+      @file.checksum.should == "{md5}#{@checksum}"
+    end
+  end
+end

data/spec/unit/file_serving/mount/file_spec.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/file_serving/mount/file'
+
+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::File do
+  it "should provide a method for clearing its cached host information" do
+    old = Puppet::FileServing::Mount::File.localmap
+    Puppet::Util::Cacher.expire
+    Puppet::FileServing::Mount::File.localmap.should_not equal(old)
+  end
+
+  it "should be invalid if it does not have a path" do
+    lambda { Puppet::FileServing::Mount::File.new("foo").validate }.should raise_error(ArgumentError)
+  end
+
+  it "should be valid if it has a path" do
+    FileTest.stubs(:directory?).returns true
+    FileTest.stubs(:readable?).returns true
+    mount = Puppet::FileServing::Mount::File.new("foo")
+    mount.path = "/foo"
+    lambda { mount.validate }.should_not raise_error(ArgumentError)
+  end
+end
+
+describe Puppet::FileServing::Mount::File, " when setting the path" do
+  before do
+    @mount = Puppet::FileServing::Mount::File.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::File, " when substituting hostnames and ip addresses into file paths" do
+  include FileServingMountTesting
+
+  before do
+    FileTest.stubs(:directory?).returns(true)
+    FileTest.stubs(:readable?).returns(true)
+    @mount = Puppet::FileServing::Mount::File.new("test")
+    @host = "host.domain.com"
+  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 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::Util::Cacher.expire
+  end
+end
+
+describe Puppet::FileServing::Mount::File, "when determining the complete file path" do
+  include FileServingMountTesting
+
+  before do
+    FileTest.stubs(:exist?).returns(true)
+    FileTest.stubs(:directory?).returns(true)
+    FileTest.stubs(:readable?).returns(true)
+    @mount = Puppet::FileServing::Mount::File.new("test")
+    @mount.path = "/mount"
+    stub_facter("myhost.mydomain.com")
+    @host = "host.domain.com"
+  end
+
+  it "should return nil if the file is absent" do
+    FileTest.stubs(:exist?).returns(false)
+    @mount.complete_path("/my/path", nil).should be_nil
+  end
+
+  it "should write a log message if the file is absent" do
+    FileTest.stubs(:exist?).returns(false)
+
+    Puppet.expects(:info).with("File does not exist or is not accessible: /mount/my/path")
+
+    @mount.complete_path("/my/path", nil)
+  end
+
+  it "should return the file path if the file is present" do
+    FileTest.stubs(:exist?).with("/my/path").returns(true)
+    @mount.complete_path("/my/path", nil).should == "/mount/my/path"
+  end
+
+  it "should treat a nil file name as the path to the mount itself" do
+    FileTest.stubs(:exist?).returns(true)
+    @mount.complete_path(nil, nil).should == "/mount"
+  end
+
+  it "should use the client host name if provided in the options" do
+    @mount.path = "/mount/%h"
+    @mount.complete_path("/my/path", @host).should == "/mount/host/my/path"
+  end
+
+  it "should perform replacements on the base path" do
+    @mount.path = "/blah/%h"
+    @mount.complete_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.complete_path("/%h/stuff", @host).should == "/blah/%h/stuff"
+  end
+
+  it "should look for files relative to its base directory" do
+    @mount.complete_path("/my/stuff", @host).should == "/mount/my/stuff"
+  end
+end
+
+describe Puppet::FileServing::Mount::File, "when finding files" do
+  include FileServingMountTesting
+
+  before do
+    FileTest.stubs(:exist?).returns(true)
+    FileTest.stubs(:directory?).returns(true)
+    FileTest.stubs(:readable?).returns(true)
+    @mount = Puppet::FileServing::Mount::File.new("test")
+    @mount.path = "/mount"
+    stub_facter("myhost.mydomain.com")
+    @host = "host.domain.com"
+
+    @request = stub 'request', :node => "foo"
+  end
+
+  it "should return the results of the complete file path" do
+    FileTest.stubs(:exist?).returns(false)
+    @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
+    @mount.find("/my/path", @request).should == "eh"
+  end
+end
+
+describe Puppet::FileServing::Mount::File, "when searching for files" do
+  include FileServingMountTesting
+
+  before do
+    FileTest.stubs(:exist?).returns(true)
+    FileTest.stubs(:directory?).returns(true)
+    FileTest.stubs(:readable?).returns(true)
+    @mount = Puppet::FileServing::Mount::File.new("test")
+    @mount.path = "/mount"
+    stub_facter("myhost.mydomain.com")
+    @host = "host.domain.com"
+
+    @request = stub 'request', :node => "foo"
+  end
+
+  it "should return the results of the complete file path as an array" do
+    FileTest.stubs(:exist?).returns(false)
+    @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
+    @mount.search("/my/path", @request).should == ["eh"]
+  end
+
+  it "should return nil if the complete path is nil" do
+    FileTest.stubs(:exist?).returns(false)
+    @mount.expects(:complete_path).with("/my/path", "foo").returns nil
+    @mount.search("/my/path", @request).should be_nil
+  end
+end