puppet 0.24.9 → 0.25.0

data/spec/unit/util/cache_accumulator.rb

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

data/spec/unit/util/cacher.rb

@@ -0,0 +1,185 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/cacher'
+
+class ExpirerTest
+    include Puppet::Util::Cacher::Expirer
+end
+
+class CacheTest
+    @@init_count = 0
+
+    include Puppet::Util::Cacher
+    cached_attr(:instance_cache) { Time.now }
+end
+
+describe Puppet::Util::Cacher::Expirer do
+    before do
+        @expirer = ExpirerTest.new
+    end
+
+    it "should be able to test whether a timestamp is expired" do
+        @expirer.should respond_to(:dependent_data_expired?)
+    end
+
+    it "should be able to expire all values" do
+        @expirer.should respond_to(:expire)
+    end
+
+    it "should consider any value to be valid if it has never been expired" do
+        @expirer.should_not be_dependent_data_expired(Time.now)
+    end
+
+    it "should consider any value created after expiration to be expired" do
+        @expirer.expire
+        @expirer.should be_dependent_data_expired(Time.now - 1)
+    end
+end
+
+describe Puppet::Util::Cacher do
+    it "should be extended with the Expirer module" do
+        Puppet::Util::Cacher.metaclass.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
+    end
+
+    it "should support defining cached attributes" do
+        CacheTest.methods.should be_include("cached_attr")
+    end
+
+    it "should default to the Cacher module as its expirer" do
+        CacheTest.new.expirer.should equal(Puppet::Util::Cacher)
+    end
+
+    describe "when using cached attributes" do
+        before do
+            @expirer = ExpirerTest.new
+            @object = CacheTest.new
+
+            @object.stubs(:expirer).returns @expirer
+        end
+
+        it "should create a getter for the cached attribute" do
+            @object.should respond_to(:instance_cache)
+        end
+
+        it "should return a value calculated from the provided block" do
+            time = Time.now
+            Time.stubs(:now).returns time
+            @object.instance_cache.should equal(time)
+        end
+
+        it "should return the cached value from the getter every time if the value is not expired" do
+            @object.instance_cache.should equal(@object.instance_cache)
+        end
+
+        it "should regenerate and return a new value using the provided block if the value has been expired" do
+            value = @object.instance_cache
+            @expirer.expire
+            @object.instance_cache.should_not equal(value)
+        end
+
+        it "should be able to trigger expiration on its expirer" do
+            @expirer.expects(:expire)
+            @object.expire
+        end
+
+        it "should do nothing when asked to expire when no expirer is available" do
+            cacher = CacheTest.new
+            class << cacher
+                def expirer
+                    nil
+                end
+            end
+            lambda { cacher.expire }.should_not raise_error
+        end
+
+        it "should be able to cache false values" do
+            @object.expects(:init_instance_cache).returns false
+            @object.instance_cache.should be_false
+            @object.instance_cache.should be_false
+        end
+
+        it "should cache values again after expiration" do
+            @object.instance_cache
+            @expirer.expire
+            @object.instance_cache.should equal(@object.instance_cache)
+        end
+
+        it "should always consider a value expired if it has no expirer" do
+            @object.stubs(:expirer).returns nil
+            @object.instance_cache.should_not equal(@object.instance_cache)
+        end
+
+        it "should allow writing of the attribute" do
+            @object.should respond_to(:instance_cache=)
+        end
+
+        it "should correctly configure timestamps for expiration when the cached attribute is written to" do
+            @object.instance_cache = "foo"
+            @expirer.expire
+            @object.instance_cache.should_not == "foo"
+        end
+
+        it "should allow specification of a ttl for cached attributes" do
+            klass = Class.new do
+                include Puppet::Util::Cacher
+            end
+
+            klass.cached_attr(:myattr, :ttl => 5)  { Time.now }
+
+            klass.attr_ttl(:myattr).should == 5
+        end
+
+        it "should allow specification of a ttl as a string" do
+            klass = Class.new do
+                include Puppet::Util::Cacher
+            end
+
+            klass.cached_attr(:myattr, :ttl => "5")  { Time.now }
+
+            klass.attr_ttl(:myattr).should == 5
+        end
+
+        it "should fail helpfully if the ttl cannot be converted to an integer" do
+            klass = Class.new do
+                include Puppet::Util::Cacher
+            end
+
+            lambda { klass.cached_attr(:myattr, :ttl => "yep")  { Time.now } }.should raise_error(ArgumentError)
+        end
+
+        it "should not check for a ttl expiration if the class does not support that method" do
+            klass = Class.new do
+                extend Puppet::Util::Cacher
+            end
+
+            klass.metaclass.cached_attr(:myattr) { "eh" }
+            klass.myattr
+        end
+
+        it "should automatically expire cached attributes whose ttl has expired, even if no expirer is present" do
+            klass = Class.new do
+                def self.to_s
+                    "CacheTestClass"
+                end
+                include Puppet::Util::Cacher
+                attr_accessor :value
+            end
+
+            klass.cached_attr(:myattr, :ttl => 5)  { self.value += 1; self.value }
+
+            now = Time.now
+            later = Time.now + 15
+
+            instance = klass.new
+            instance.value = 0
+            instance.myattr.should == 1
+
+            Time.expects(:now).returns later
+
+            # This call should get the new Time value, which should expire the old value
+            instance.myattr.should == 2
+        end
+    end
+end

data/spec/unit/util/checksums.rb

@@ -28,6 +28,14 @@ describe Puppet::Util::Checksums do
         end
     end
 
+    it "should have a method for stripping a sum type from an existing checksum" do
+        @summer.sumtype("{md5}asdfasdfa").should == "md5"
+    end
+
+    it "should return a nil sumtype if the checksum does not mention a checksum type" do
+        @summer.sumtype("asdfasdfa").should be_nil
+    end
+
     {:md5 => Digest::MD5, :sha1 => Digest::SHA1}.each do |sum, klass|
         describe("when using %s" % sum) do
             it "should use #{klass} to calculate string checksums" do
@@ -42,7 +50,7 @@ describe Puppet::Util::Checksums do
                 file = "/path/to/my/file"
 
                 fh = mock 'filehandle'
-                fh.expects(:read).with(512).times(3).returns("firstline").then.returns("secondline").then.returns(nil)
+                fh.expects(:read).with(4096).times(3).returns("firstline").then.returns("secondline").then.returns(nil)
                 #fh.expects(:read).with(512).returns("secondline")
                 #fh.expects(:read).with(512).returns(nil)
 

data/spec/unit/util/feature.rb

@@ -0,0 +1,72 @@
+#!/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/feature'
+
+describe Puppet::Util::Feature do
+    before do
+        @features = Puppet::Util::Feature.new("features")
+        @features.stubs(:warn)
+    end
+
+    it "should consider undefined features to be absent" do
+        @features.should_not be_defined_feature
+    end
+
+    it "should be able to add new features" do
+        @features.add(:myfeature) {}
+        @features.should respond_to(:myfeature?)
+    end
+
+    it "should call associated code when loading a feature" do
+        $loaded_feature = false
+        @features.add(:myfeature) { $loaded_feature = true}
+        $loaded_feature.should be_true
+    end
+
+    it "should consider a feature absent when the feature load fails" do
+        @features.add(:failer) { raise "foo" }
+        @features.should_not be_failer
+    end
+
+    it "should consider a feature to be absent when the feature load returns false" do
+        @features.add(:failer) { false }
+        @features.should_not be_failer
+    end
+
+    it "should consider a feature to be present when the feature load returns true" do
+        @features.add(:available) { true }
+        @features.should be_available
+    end
+
+    it "should cache the results of a feature load" do
+        $loaded_feature = 0
+        @features.add(:myfeature) { $loaded_feature += 1 }
+        @features.myfeature?
+        @features.myfeature?
+        $loaded_feature.should == 1
+    end
+
+    it "should support features with libraries" do
+        lambda { @features.add(:puppet, :libs => %w{puppet}) }.should_not raise_error
+    end
+
+    it "should consider a feature to be present if all of its libraries are present" do
+        @features.add(:myfeature, :libs => %w{foo bar})
+        @features.expects(:require).with("foo")
+        @features.expects(:require).with("bar")
+
+        @features.should be_myfeature
+    end
+
+    it "should log and consider a feature to be absent if any of its libraries are absent" do
+        @features.add(:myfeature, :libs => %w{foo bar})
+        @features.expects(:require).with("foo").raises(LoadError)
+        @features.stubs(:require).with("bar")
+
+        Puppet.expects(:debug)
+
+        @features.should_not be_myfeature
+    end
+end

data/spec/unit/util/filetype.rb

@@ -27,20 +27,10 @@ describe Puppet::Util::FileType do
             @file.backup
         end
 
-        it "should use the filebucket named 'puppet' if it finds one" do
+        it "should use the default filebucket" do
             bucket = mock 'bucket'
             bucket.expects(:bucket).returns "mybucket"
 
-            Puppet::Type.type(:filebucket).expects(:[]).with("puppet").returns bucket
-
-            @file.bucket.should == "mybucket"
-        end
-
-        it "should use the default filebucket if none named 'puppet' is found" do
-            bucket = mock 'bucket'
-            bucket.expects(:bucket).returns "mybucket"
-
-            Puppet::Type.type(:filebucket).expects(:[]).with("puppet").returns nil
             Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
 
             @file.bucket.should == "mybucket"

data/spec/unit/util/json.rb

@@ -0,0 +1,21 @@
+#!/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/json'
+
+class JsonUtil
+    include Puppet::Util::Json
+end
+
+describe Puppet::Util::Json do
+    it "should fail if no data is provided" do
+        lambda { JsonUtil.new.json_create("json_class" => "foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should call 'from_json' with the provided data" do
+        json = JsonUtil.new
+        json.expects(:from_json).with("mydata")
+        json.json_create("json_class" => "foo", "data" => "mydata")
+    end
+end

data/spec/unit/util/log.rb

@@ -5,6 +5,14 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
 require 'puppet/util/log'
 
 describe Puppet::Util::Log do
+    it "should be able to close all log destinations" do
+        Puppet::Util::Log.expects(:destinations).returns %w{foo bar}
+        Puppet::Util::Log.expects(:close).with("foo")
+        Puppet::Util::Log.expects(:close).with("bar")
+
+        Puppet::Util::Log.close_all
+    end
+
     describe "instances" do
         before do
             Puppet::Util::Log.stubs(:newmessage)
@@ -103,5 +111,42 @@ describe Puppet::Util::Log do
             report.should be_include(log.source)
             report.should be_include(log.time.to_s)
         end
+
+        describe "when setting the source as a RAL object" do
+            it "should tag itself with any tags the source has" do
+                source = Puppet::Type.type(:file).new :path => "/foo/bar"
+                log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+                source.tags.each do |tag|
+                    log.tags.should be_include(tag)
+                end
+            end
+
+            it "should copy over any version information" do
+                catalog = Puppet::Resource::Catalog.new
+                catalog.version = 25
+                source = Puppet::Type.type(:file).new :path => "/foo/bar"
+                catalog.add_resource source
+
+                log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+                log.version.should == 25
+            end
+
+            it "should copy over any file and line information" do
+                source = Puppet::Type.type(:file).new :path => "/foo/bar"
+                source.file = "/my/file"
+                source.line = 50
+                log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+                log.file.should == "/my/file"
+                log.line.should == 50
+            end
+        end
+
+        describe "when setting the source as a non-RAL object" do
+            it "should not try to copy over file, version, line, or tag information" do
+                source = Puppet::Module.new("foo")
+                source.expects(:file).never
+                log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+            end
+        end
     end
 end