puppet 0.25.5 → 2.6.0

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

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

data/spec/unit/util/autoload_spec.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/util/autoload'
+
+describe Puppet::Util::Autoload do
+  before do
+    @autoload = Puppet::Util::Autoload.new("foo", "tmp")
+
+    @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
+
+  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
+      Puppet.stubs(:[]).with(:libdir).returns(%w{/libdir1 /lib/dir/two /third/lib/dir}.join(File::PATH_SEPARATOR))
+      @autoload.expects(:module_directories).returns %w{/one /two}
+      @autoload.search_directories.should == %w{/one /two /libdir1 /lib/dir/two /third/lib/dir} + $LOAD_PATH
+    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 die with Puppet::Error if a #{error.to_s} exception is thrown" do
+        @autoload.stubs(:file_exist?).returns true
+
+        Kernel.expects(:load).raises error
+
+        lambda { @autoload.load("foo") }.should raise_error(Puppet::Error)
+      end
+    end
+
+    it "should not raise an error if the file is missing" do
+      @autoload.load("foo").should == false
+    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")
+
+      $LOADED_FEATURES.should be_include("tmp/myfile.rb")
+    end
+  end
+
+  describe "when loading all files" do
+    before do
+      @autoload.stubs(:searchpath).returns %w{/a}
+      Dir.stubs(:glob).returns "/path/to/file.rb"
+
+      @autoload.class.stubs(:loaded?).returns(false)
+    end
+
+    [RuntimeError, LoadError, SyntaxError].each do |error|
+      it "should die an if a #{error.to_s} exception is thrown" do
+        Kernel.expects(:require).raises error
+
+        lambda { @autoload.loadall }.should raise_error(Puppet::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/backups_spec.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

data/spec/unit/util/cache_accumulator_spec.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/util/rails/cache_accumulator'
+
+describe Puppet::Util::CacheAccumulator do
+  before :each do
+    @test_class = Class.new do
+      attr_accessor :name
+
+      include Puppet::Util::CacheAccumulator
+      accumulates :name
+
+      def initialize(n)
+        self.name = n
+      end
+    end
+  end
+
+  it 'should delegate to underlying find_or_create_by_* method and accumulate results' do
+    @test_class.expects(:find_or_create_by_name).with('foo').returns(@test_class.new('foo')).once
+    obj = @test_class.accumulate_by_name('foo')
+    obj.name.should == 'foo'
+    @test_class.accumulate_by_name('foo').should == obj
+  end
+
+  it 'should delegate bulk lookups to find with appropriate arguments and returning result count' do
+
+    @test_class.expects(:find).with(
+      :all,
+
+        :conditions => {:name => ['a', 'b', 'c']}
+          ).returns(['a','b','c'].collect {|n| @test_class.new(n)}).once
+    @test_class.accumulate_by_name('a', 'b', 'c').should == 3
+  end
+
+  it 'should only need find_or_create_by_name lookup for missing bulk entries' do
+
+    @test_class.expects(:find).with(
+      :all,
+
+        :conditions => {:name => ['a', 'b']}
+          ).returns([ @test_class.new('a') ]).once
+    @test_class.expects(:find_or_create_by_name).with('b').returns(@test_class.new('b')).once
+    @test_class.expects(:find_or_create_by_name).with('a').never
+    @test_class.accumulate_by_name('a','b').should == 1
+    @test_class.accumulate_by_name('a').name.should == 'a'
+    @test_class.accumulate_by_name('b').name.should == 'b'
+  end
+
+  it 'should keep consumer classes separate' do
+    @alt_class = Class.new do
+      attr_accessor :name
+
+      include Puppet::Util::CacheAccumulator
+      accumulates :name
+
+      def initialize(n)
+        self.name = n
+      end
+    end
+    name = 'foo'
+    @test_class.expects(:find_or_create_by_name).with(name).returns(@test_class.new(name)).once
+    @alt_class.expects(:find_or_create_by_name).with(name).returns(@alt_class.new(name)).once
+
+    [@test_class, @alt_class].each do |klass|
+      klass.accumulate_by_name(name).name.should == name
+      klass.accumulate_by_name(name).class.should == klass
+    end
+  end
+
+  it 'should clear accumulated cache with reset_*_accumulator' do
+    # figure out how to test this appropriately...
+  end
+end