puppet 0.24.9 → 0.25.0

data/spec/unit/file_serving/metadata.rb

@@ -5,8 +5,8 @@ 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)
+    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
@@ -16,39 +16,36 @@ describe Puppet::FileServing::Metadata do
     it "should should include the IndirectionHooks module in its indirection" do
         Puppet::FileServing::Metadata.indirection.metaclass.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
 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
+        @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"
     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
+        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(@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)
+        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(@full).raises(Errno::ENOENT)
-        proc { @metadata.collect_attributes()}.should raise_error(Errno::ENOENT)
+        File.expects(:lstat).with(@path).raises(Errno::ENOENT)
+        proc { @metadata.collect()}.should raise_error(Errno::ENOENT)
     end
 end
 
@@ -59,9 +56,9 @@ describe Puppet::FileServing::Metadata, " when collecting attributes" do
         @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 = Puppet::FileServing::Metadata.new("/my/file")
         @metadata.stubs(:md5_file).returns(@checksum)
-        @metadata.collect_attributes
+        @metadata.collect
     end
 
     it "should be able to produce xmlrpc-style attribute information" do
@@ -103,7 +100,7 @@ describe Puppet::FileServing::Metadata, " when collecting attributes" do
             time = Time.now
             @metadata.checksum_type = "mtime"
             @metadata.expects(:mtime_file).returns(@time)
-            @metadata.collect_attributes
+            @metadata.collect
             @metadata.checksum.should == "{mtime}" + @time.to_s
         end
 
@@ -120,19 +117,19 @@ describe Puppet::FileServing::Metadata, " when collecting attributes" do
         end
 
         it "should only use checksums of type 'ctime' for directories" do
-            @metadata.collect_attributes
+            @metadata.collect
             @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.collect
             @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.collect
             @metadata.attributes_with_tabs.should == "#{0755.to_s}\tdirectory\t10\t20\t{ctime}#{@time.to_s}"
         end
     end
@@ -141,7 +138,7 @@ describe Puppet::FileServing::Metadata, " when collecting attributes" do
         before do
             @stat.stubs(:ftype).returns("link")
             File.expects(:readlink).with("/my/file").returns("/path/to/link")
-            @metadata.collect_attributes
+            @metadata.collect
         end
 
         it "should read links instead of returning their checksums" do
@@ -156,32 +153,22 @@ 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 = 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"
 
-        file.collect_attributes
+        file.collect
         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 = 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"
 
-        file.collect_attributes
+        file.collect
         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

@@ -3,18 +3,9 @@
 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
+    it "should use 'mount[$name]' as its string form" do
+        Puppet::FileServing::Mount.new("foo").to_s.should == "mount[foo]"
     end
 end
 
@@ -26,118 +17,16 @@ describe Puppet::FileServing::Mount, " when initializing" do
     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
+    it "should fail" do
+        lambda { Puppet::FileServing::Mount.new("test").find("foo", :one => "two") }.should raise_error(NotImplementedError)
     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"
+describe Puppet::FileServing::Mount, " when searching for files" do
+    it "should fail" do
+        lambda { Puppet::FileServing::Mount.new("test").search("foo", :one => "two") }.should raise_error(NotImplementedError)
     end
 end

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

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