puppet 0.24.9 → 0.25.0

data/spec/unit/type/user.rb

@@ -13,14 +13,12 @@ describe user do
         @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
     end
 
-    after { user.clear }
-
     it "should have a default provider inheriting from Puppet::Provider" do
         user.defaultprovider.ancestors.should be_include(Puppet::Provider)
     end
 
     it "should be able to create a instance" do
-        user.create(:name => "foo").should_not be_nil
+        user.new(:name => "foo").should_not be_nil
     end
 
     it "should have an allows_duplicates feature" do
@@ -41,7 +39,13 @@ describe user do
 
     describe "instances" do
         it "should have a valid provider" do
-            user.create(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
+            user.new(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
+        end
+
+        it "should delegate existence questions to its provider" do
+            instance = user.new(:name => "foo")
+            instance.provider.expects(:exists?).returns "eh"
+            instance.exists?.should == "eh"
         end
     end
 
@@ -75,11 +79,14 @@ describe user do
 
     describe "when retrieving all current values" do
         before do
-            @user = user.create(:name => "foo", :uid => 10, :gid => 10)
-            @properties = {}
+            @user = user.new(:name => "foo", :uid => 10)
         end
 
         it "should return a hash containing values for all set properties" do
+            @user[:gid] = 10
+            @user.property(:ensure).expects(:retrieve).returns :present
+            @user.property(:uid).expects(:retrieve).returns 15
+            @user.property(:gid).expects(:retrieve).returns 15
             values = @user.retrieve
             [@user.property(:uid), @user.property(:gid)].each { |property| values.should be_include(property) }
         end
@@ -236,7 +243,7 @@ describe user do
         end
 
         it "should fail if a ':' is included in the password" do
-            lambda { @password.should = "some:thing" }.should raise_error(ArgumentError)
+            lambda { @password.should = "some:thing" }.should raise_error(Puppet::Error)
         end
 
         it "should allow the value to be set to :absent" do
@@ -259,15 +266,16 @@ describe user do
     describe "when user has roles" do
         it "should autorequire roles" do
             #this is a little funky because the autorequire depends on a property with a feature
-            testuser = Puppet.type(:user).create(:name => "testuser")
+            testuser = Puppet::Type.type(:user).new(:name => "testuser")
             testuser.provider.class.expects(:feature?).with(:manages_solaris_rbac).returns(true)
             testuser[:roles] = "testrole"
 
-            testrole = Puppet.type(:user).create(:name => "testrole")
+            testrole = Puppet::Type.type(:user).new(:name => "testrole")
 
-            config = Puppet::Node::Catalog.new :testing do |conf|
+            config = Puppet::Resource::Catalog.new :testing do |conf|
                 [testuser, testrole].each { |resource| conf.add_resource resource }
             end
+            Puppet::Type::User::ProviderDirectoryservice.stubs(:get_macosx_version_major).returns "10.5"
 
             rel = testuser.autorequire[0]
             rel.source.ref.should == testrole.ref

data/spec/unit/type/zfs.rb

@@ -25,16 +25,16 @@ describe zfs do
         provider = mock "provider"
         provider.stubs(:name).returns(:solaris)
         zfs.stubs(:defaultprovider).returns(provider)
-        Puppet.type(:zpool).stubs(:defaultprovider).returns(provider)
+        Puppet::Type.type(:zpool).stubs(:defaultprovider).returns(provider)
 
 
-        foo_pool = Puppet.type(:zpool).create(:name => "foo")
+        foo_pool = Puppet::Type.type(:zpool).new(:name => "foo")
 
-        foo_bar_zfs = Puppet.type(:zfs).create(:name => "foo/bar")
-        foo_bar_baz_zfs = Puppet.type(:zfs).create(:name => "foo/bar/baz")
-        foo_bar_baz_buz_zfs = Puppet.type(:zfs).create(:name => "foo/bar/baz/buz")
+        foo_bar_zfs = Puppet::Type.type(:zfs).new(:name => "foo/bar")
+        foo_bar_baz_zfs = Puppet::Type.type(:zfs).new(:name => "foo/bar/baz")
+        foo_bar_baz_buz_zfs = Puppet::Type.type(:zfs).new(:name => "foo/bar/baz/buz")
 
-        config = Puppet::Node::Catalog.new :testing do |conf|
+        config = Puppet::Resource::Catalog.new :testing do |conf|
             [foo_pool, foo_bar_zfs, foo_bar_baz_zfs, foo_bar_baz_buz_zfs].each { |resource| conf.add_resource resource }
         end
 

data/spec/unit/util/autoload.rb

@@ -11,21 +11,106 @@ describe Puppet::Util::Autoload do
         @autoload.stubs(:eachdir).yields "/my/dir"
     end
 
+    it "should use the Cacher module" do
+        Puppet::Util::Autoload.ancestors.should be_include(Puppet::Util::Cacher)
+    end
+
+    it "should use a ttl of 15 for the search path" do
+        Puppet::Util::Autoload.attr_ttl(:searchpath).should == 15
+    end
+
+    describe "when building the search path" do
+        it "should collect all of the plugins and lib directories that exist in the current environment's module path" do
+            Puppet.settings.expects(:value).with(:environment).returns "foo"
+            Puppet.settings.expects(:value).with(:modulepath, :foo).returns "/a:/b:/c"
+            Dir.expects(:entries).with("/a").returns %w{one two}
+            Dir.expects(:entries).with("/b").returns %w{one two}
+
+            FileTest.stubs(:directory?).returns false
+            FileTest.expects(:directory?).with("/a").returns true
+            FileTest.expects(:directory?).with("/b").returns true
+            %w{/a/one/plugins /a/two/lib /b/one/plugins /b/two/lib}.each do |d|
+                FileTest.expects(:directory?).with(d).returns true
+            end
+
+            @autoload.module_directories.should == %w{/a/one/plugins /a/two/lib /b/one/plugins /b/two/lib}
+        end
+
+        it "should not look for lib directories in directories starting with '.'" do
+            Puppet.settings.expects(:value).with(:environment).returns "foo"
+            Puppet.settings.expects(:value).with(:modulepath, :foo).returns "/a"
+            Dir.expects(:entries).with("/a").returns %w{. ..}
+
+            FileTest.expects(:directory?).with("/a").returns true
+            FileTest.expects(:directory?).with("/a/./lib").never
+            FileTest.expects(:directory?).with("/a/./plugins").never
+            FileTest.expects(:directory?).with("/a/../lib").never
+            FileTest.expects(:directory?).with("/a/../plugins").never
+
+            @autoload.module_directories
+        end
+
+        it "should include the module directories, the Puppet libdir, and all of the Ruby load directories" do
+            @autoload.expects(:module_directories).returns %w{/one /two}
+            @autoload.search_directories.should == ["/one", "/two", Puppet[:libdir], $:].flatten
+        end
+
+        it "should include in its search path all of the search directories that have a subdirectory matching the autoload path" do
+            @autoload = Puppet::Util::Autoload.new("foo", "loaddir")
+            @autoload.expects(:search_directories).returns %w{/one /two /three}
+            FileTest.expects(:directory?).with("/one/loaddir").returns true
+            FileTest.expects(:directory?).with("/two/loaddir").returns false
+            FileTest.expects(:directory?).with("/three/loaddir").returns true
+            @autoload.searchpath.should == ["/one/loaddir", "/three/loaddir"]
+        end
+    end
+
+    it "should include its FileCache module" do
+        Puppet::Util::Autoload.ancestors.should be_include(Puppet::Util::Autoload::FileCache)
+    end
+
     describe "when loading a file" do
+        before do
+            @autoload.stubs(:searchpath).returns %w{/a}
+        end
+
         [RuntimeError, LoadError, SyntaxError].each do |error|
             it "should not die an if a #{error.to_s} exception is thrown" do
-                FileTest.stubs(:exists?).returns true
+                @autoload.stubs(:file_exist?).returns true
 
                 Kernel.expects(:load).raises error
 
-                lambda { @autoload.load("foo") }.should_not raise_error
+                @autoload.load("foo")
             end
         end
+
+        it "should skip files that it knows are missing" do
+            @autoload.expects(:named_file_missing?).with("foo").returns true
+            @autoload.expects(:eachdir).never
+
+            @autoload.load("foo")
+        end
+
+        it "should register that files are missing if they cannot be found" do
+            @autoload.load("foo")
+
+            @autoload.should be_named_file_missing("foo")
+        end
+
+        it "should register loaded files with the main loaded file list so they are not reloaded by ruby" do
+            @autoload.stubs(:file_exist?).returns true
+            Kernel.stubs(:load)
+
+            @autoload.load("myfile")
+
+            $".should be_include("tmp/myfile.rb")
+        end
     end
 
     describe "when loading all files" do
         before do
-            Dir.stubs(:glob).returns "file.rb"
+            @autoload.stubs(:searchpath).returns %w{/a}
+            Dir.stubs(:glob).returns "/path/to/file.rb"
         end
 
         [RuntimeError, LoadError, SyntaxError].each do |error|
@@ -35,5 +120,11 @@ describe Puppet::Util::Autoload do
                 lambda { @autoload.loadall }.should_not raise_error
             end
         end
+
+        it "should require the full path to the file" do
+            Kernel.expects(:require).with("/path/to/file.rb")
+
+            @autoload.loadall
+        end
     end
 end

data/spec/unit/util/autoload/file_cache.rb

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/util/autoload/file_cache'
+
+class FileCacheTester
+    include Puppet::Util::Autoload::FileCache
+end
+
+describe Puppet::Util::Autoload::FileCache do
+    before do
+        @cacher = FileCacheTester.new
+    end
+
+    after do
+        Puppet::Util::Autoload::FileCache.clear
+    end
+
+    describe "when checking whether files exist" do
+        it "should have a method for testing whether a file exists" do
+            @cacher.should respond_to(:file_exist?)
+        end
+
+        it "should use lstat to determine whether a file exists" do
+            File.expects(:lstat).with("/my/file")
+            @cacher.file_exist?("/my/file")
+        end
+
+        it "should consider a file as absent if its lstat fails" do
+            File.expects(:lstat).with("/my/file").raises Errno::ENOENT
+            @cacher.should_not be_file_exist("/my/file")
+        end
+
+        it "should consider a file as absent if the directory is absent" do
+            File.expects(:lstat).with("/my/file").raises Errno::ENOTDIR
+            @cacher.should_not be_file_exist("/my/file")
+        end
+
+        it "should consider a file as absent permissions are missing" do
+            File.expects(:lstat).with("/my/file").raises Errno::EACCES
+            @cacher.should_not be_file_exist("/my/file")
+        end
+
+        it "should raise non-fs exceptions" do
+            File.expects(:lstat).with("/my/file").raises ArgumentError
+            lambda { @cacher.file_exist?("/my/file") }.should raise_error(ArgumentError)
+        end
+
+        it "should consider a file as present if its lstat succeeds" do
+            File.expects(:lstat).with("/my/file").returns mock("stat")
+            @cacher.should be_file_exist("/my/file")
+        end
+
+        it "should not stat a file twice in quick succession when the file is missing" do
+            File.expects(:lstat).with("/my/file").once.raises Errno::ENOENT
+            @cacher.should_not be_file_exist("/my/file")
+            @cacher.should_not be_file_exist("/my/file")
+        end
+
+        it "should not stat a file twice in quick succession when the file is present" do
+            File.expects(:lstat).with("/my/file").once.returns mock("stat")
+            @cacher.should be_file_exist("/my/file")
+            @cacher.should be_file_exist("/my/file")
+        end
+
+        it "should expire cached data after 15 seconds" do
+            now = Time.now
+
+            later = now + 16
+
+            Time.expects(:now).times(3).returns(now).then.returns(later).then.returns(later)
+            File.expects(:lstat).with("/my/file").times(2).returns(mock("stat")).then.raises Errno::ENOENT
+            @cacher.should be_file_exist("/my/file")
+            @cacher.should_not be_file_exist("/my/file")
+        end
+
+        it "should share cached data across autoload instances" do
+            File.expects(:lstat).with("/my/file").once.returns mock("stat")
+            other = Puppet::Util::Autoload.new("bar", "tmp")
+
+            @cacher.should be_file_exist("/my/file")
+            other.should be_file_exist("/my/file")
+        end
+    end
+
+    describe "when checking whether files exist" do
+        before do
+            @stat = stub 'stat', :directory? => true
+        end
+
+        it "should have a method for determining whether a directory exists" do
+            @cacher.should respond_to(:directory_exist?)
+        end
+
+        it "should use lstat to determine whether a directory exists" do
+            File.expects(:lstat).with("/my/file").returns @stat
+            @cacher.directory_exist?("/my/file")
+        end
+
+        it "should consider a directory as absent if its lstat fails" do
+            File.expects(:lstat).with("/my/file").raises Errno::ENOENT
+            @cacher.should_not be_directory_exist("/my/file")
+        end
+
+        it "should consider a file as absent if the directory is absent" do
+            File.expects(:lstat).with("/my/file").raises Errno::ENOTDIR
+            @cacher.should_not be_directory_exist("/my/file")
+        end
+
+        it "should consider a file as absent permissions are missing" do
+            File.expects(:lstat).with("/my/file").raises Errno::EACCES
+            @cacher.should_not be_directory_exist("/my/file")
+        end
+
+        it "should raise non-fs exceptions" do
+            File.expects(:lstat).with("/my/file").raises ArgumentError
+            lambda { @cacher.directory_exist?("/my/file") }.should raise_error(ArgumentError)
+        end
+
+        it "should consider a directory as present if its lstat succeeds and the stat is of a directory" do
+            @stat.expects(:directory?).returns true
+            File.expects(:lstat).with("/my/file").returns @stat
+            @cacher.should be_directory_exist("/my/file")
+        end
+
+        it "should consider a directory as absent if its lstat succeeds and the stat is not of a directory" do
+            @stat.expects(:directory?).returns false
+            File.expects(:lstat).with("/my/file").returns @stat
+            @cacher.should_not be_directory_exist("/my/file")
+        end
+
+        it "should not stat a directory twice in quick succession when the file is missing" do
+            File.expects(:lstat).with("/my/file").once.raises Errno::ENOENT
+            @cacher.should_not be_directory_exist("/my/file")
+            @cacher.should_not be_directory_exist("/my/file")
+        end
+
+        it "should not stat a directory twice in quick succession when the file is present" do
+            File.expects(:lstat).with("/my/file").once.returns @stat
+            @cacher.should be_directory_exist("/my/file")
+            @cacher.should be_directory_exist("/my/file")
+        end
+
+        it "should not consider a file to be a directory based on cached data" do
+            @stat.stubs(:directory?).returns false
+            File.stubs(:lstat).with("/my/file").returns @stat
+            @cacher.file_exist?("/my/file")
+            @cacher.should_not be_directory_exist("/my/file")
+        end
+
+        it "should share cached data across autoload instances" do
+            File.expects(:lstat).with("/my/file").once.returns @stat
+            other = Puppet::Util::Autoload.new("bar", "tmp")
+
+            @cacher.should be_directory_exist("/my/file")
+            other.should be_directory_exist("/my/file")
+        end
+    end
+
+    describe "when checking whether a named file exists" do
+        it "should have a method for testing whether a named file is missing" do
+            @cacher.should respond_to(:named_file_missing?)
+        end
+
+        it "should have a method for registering that a named file is missing" do
+            @cacher.should respond_to(:named_file_is_missing)
+        end
+
+        it "should cache that a file is missing for 15 seconds" do
+            now = Time.now
+
+            later = now + 16
+
+            Time.expects(:now).times(2).returns(now).then.returns(later)
+            @cacher.named_file_is_missing("foo")
+            @cacher.should_not be_named_file_missing("foo")
+        end
+
+        it "should return false when registering a file as missing" do
+            @cacher.named_file_is_missing("foo").should be_false
+        end
+    end
+end

data/spec/unit/util/backups.rb

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/backups'
+include PuppetTest
+
+describe Puppet::Util::Backups do
+    before do
+        FileTest.stubs(:exists?).returns true
+    end
+
+    describe "when backing up a file" do
+        it "should noop if the file does not exist" do
+            FileTest.expects(:exists?).returns false
+            file = Puppet::Type.type(:file).new(:name => '/no/such/file')
+            file.expects(:bucket).never
+
+            file.perform_backup
+        end
+
+        it "should succeed silently if self[:backup] is false" do
+            file = Puppet::Type.type(:file).new(:name => '/no/such/file', :backup => false)
+            file.expects(:bucket).never
+            FileTest.expects(:exists?).never
+            file.perform_backup
+        end
+
+        it "a bucket should be used when provided" do
+            path = '/my/file'
+
+            File.stubs(:stat).with(path).returns(mock('stat', :ftype => 'file'))
+
+            file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
+            bucket = stub('bucket', 'name' => 'foo')
+            file.stubs(:bucket).returns bucket
+
+            bucket.expects(:backup).with(path).returns("mysum")
+
+            file.perform_backup
+        end
+
+        it "should propagate any exceptions encountered when backing up to a filebucket" do
+            path = '/my/file'
+
+            File.stubs(:stat).with(path).returns(mock('stat', :ftype => 'file'))
+
+            file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
+            bucket = stub('bucket', 'name' => 'foo')
+            file.stubs(:bucket).returns bucket
+
+            bucket.expects(:backup).raises ArgumentError
+
+            lambda { file.perform_backup }.should raise_error(ArgumentError)
+        end
+
+        describe "and no filebucket is configured" do
+            it "should remove any local backup if one exists" do
+                path = '/my/file'
+                FileTest.stubs(:exists?).returns true
+
+                backup = path + ".foo"
+
+                File.expects(:lstat).with(backup).returns stub("stat", :ftype => "file")
+                File.expects(:unlink).with(backup)
+
+                FileUtils.stubs(:cp_r)
+
+                file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
+                file.perform_backup
+            end
+
+            it "should fail when the old backup can't be removed" do
+                path = '/my/file'
+                FileTest.stubs(:exists?).returns true
+
+                backup = path + ".foo"
+
+                File.expects(:lstat).with(backup).returns stub("stat", :ftype => "file")
+                File.expects(:unlink).raises ArgumentError
+
+                FileUtils.expects(:cp_r).never
+
+                file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
+                lambda { file.perform_backup }.should raise_error(Puppet::Error)
+            end
+
+            it "should not try to remove backups that don't exist" do
+                path = '/my/file'
+                FileTest.stubs(:exists?).returns true
+
+                backup = path + ".foo"
+
+                File.expects(:lstat).with(backup).raises(Errno::ENOENT)
+                File.expects(:unlink).never
+
+                FileUtils.stubs(:cp_r)
+
+                file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
+                file.perform_backup
+            end
+
+            it "a copy should be created in the local directory" do
+                path = '/my/file'
+                FileTest.stubs(:exists?).with(path).returns true
+
+                FileUtils.expects(:cp_r).with(path, path + ".foo", :preserve => true)
+
+                file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
+                file.perform_backup.should be_true
+            end
+
+            it "should propagate exceptions if no backup can be created" do
+                path = '/my/file'
+                FileTest.stubs(:exists?).with(path).returns true
+
+                FileUtils.expects(:cp_r).raises ArgumentError
+
+                file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
+                lambda { file.perform_backup }.should raise_error(Puppet::Error)
+            end
+        end
+    end
+
+    describe "when backing up a directory" do
+        it "a bucket should work when provided" do
+            path = '/my/dir'
+
+            File.stubs(:file?).returns true
+            Find.expects(:find).with(path).yields("/my/dir/file")
+
+            bucket = stub('bucket', :name => "eh")
+            bucket.expects(:backup).with("/my/dir/file").returns true
+
+            file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
+            file.stubs(:bucket).returns bucket
+
+            File.stubs(:stat).with(path).returns(stub('stat', :ftype => 'directory'))
+
+            file.perform_backup
+        end
+
+        it "should do nothing when recursing" do
+            path = '/my/dir'
+
+            bucket = stub('bucket', :name => "eh")
+            bucket.expects(:backup).never
+
+            file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo', :recurse => true)
+            file.stubs(:bucket).returns bucket
+
+            File.stubs(:stat).with(path).returns(stub('stat', :ftype => 'directory'))
+
+            Find.expects(:find).never
+
+            file.perform_backup
+        end
+    end
+end