puppet 0.24.6 → 0.24.7

data/spec/unit/util/storage.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'yaml'
+require 'tempfile'
+
+require 'puppet/util/storage'
+
+describe Puppet::Util::Storage do
+    before(:all) do
+        Puppet[:statedir] = Dir.tmpdir()
+    end
+
+    before(:each) do
+        Puppet::Util::Storage.clear()
+    end
+    
+    after do
+        Puppet::Type.type(:file).clear
+    end
+
+    describe "when caching a symbol" do
+        it "should return an empty hash" do
+            Puppet::Util::Storage.cache(:yayness).should == {}
+            Puppet::Util::Storage.cache(:more_yayness).should == {}
+        end
+
+        it "should add the symbol to its internal state" do
+            Puppet::Util::Storage.cache(:yayness)
+            Puppet::Util::Storage.state().should == {:yayness=>{}}
+        end
+
+        it "should not clobber existing state when caching additional objects" do
+            Puppet::Util::Storage.cache(:yayness)
+            Puppet::Util::Storage.state().should == {:yayness=>{}}
+            Puppet::Util::Storage.cache(:bubblyness)
+            Puppet::Util::Storage.state().should == {:yayness=>{},:bubblyness=>{}}
+        end
+    end
+
+    describe "when caching a Puppet::Type" do
+        before(:all) do
+            @file_test = Puppet.type(:file).create(:name => "/yayness", :check => %w{checksum type})
+            @exec_test = Puppet.type(:exec).create(:name => "/bin/ls /yayness")
+        end
+
+        it "should return an empty hash" do
+            Puppet::Util::Storage.cache(@file_test).should == {}
+            Puppet::Util::Storage.cache(@exec_test).should == {}
+        end
+
+        it "should add the resource ref to its internal state" do
+            Puppet::Util::Storage.state().should == {}
+            Puppet::Util::Storage.cache(@file_test)
+            Puppet::Util::Storage.state().should == {"File[/yayness]"=>{}}
+            Puppet::Util::Storage.cache(@exec_test)
+            Puppet::Util::Storage.state().should == {"File[/yayness]"=>{}, "Exec[/bin/ls /yayness]"=>{}}
+        end
+    end
+
+    describe "when caching invalid objects" do
+        before(:all) do
+            @bogus_objects = [ {}, [], "foo", 42, nil, Tempfile.new('storage_test') ]
+        end
+
+        it "should raise an ArgumentError" do
+            @bogus_objects.each do |object|
+                proc { Puppet::Util::Storage.cache(object) }.should raise_error()
+            end
+        end
+
+        it "should not add anything to its internal state" do
+            @bogus_objects.each do |object|
+                begin
+                    Puppet::Util::Storage.cache(object)
+                rescue
+                    Puppet::Util::Storage.state().should == {}
+                end
+            end
+        end
+    end
+
+    it "should clear its internal state when clear() is called" do
+        Puppet::Util::Storage.cache(:yayness)
+        Puppet::Util::Storage.state().should == {:yayness=>{}}
+        Puppet::Util::Storage.clear()
+        Puppet::Util::Storage.state().should == {}
+    end
+
+    describe "when loading from the state file" do
+        before do
+            Puppet.settings.stubs(:use).returns(true)
+        end
+
+        describe "when the state file/directory does not exist" do
+            before(:each) do
+                transient = Tempfile.new('storage_test')
+                @path = transient.path()
+                transient.close!()
+            end
+            
+            it "should not fail to load()" do
+                FileTest.exists?(@path).should be_false()
+                Puppet[:statedir] = @path
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+                Puppet[:statefile] = @path
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+            end
+
+            it "should not lose its internal state when load() is called" do
+                FileTest.exists?(@path).should be_false()
+
+                Puppet::Util::Storage.cache(:yayness)
+                Puppet::Util::Storage.state().should == {:yayness=>{}}
+                
+                Puppet[:statefile] = @path
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+                
+                Puppet::Util::Storage.state().should == {:yayness=>{}}
+            end
+        end
+
+        describe "when the state file/directory exists" do
+            before(:each) do
+                @state_file = Tempfile.new('storage_test')
+                @saved_statefile = Puppet[:statefile]
+                Puppet[:statefile] = @state_file.path()
+            end
+
+            it "should overwrite its internal state if load() is called" do
+                # Should the state be overwritten even if Puppet[:statefile] is not valid YAML?
+                Puppet::Util::Storage.cache(:yayness)
+                Puppet::Util::Storage.state().should == {:yayness=>{}}
+
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+                Puppet::Util::Storage.state().should == {}
+            end
+
+            it "should restore its internal state if the state file contains valid YAML" do
+                test_yaml = {'File["/yayness"]'=>{"name"=>{:a=>:b,:c=>:d}}}
+                YAML.expects(:load).returns(test_yaml)
+
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+                Puppet::Util::Storage.state().should == test_yaml
+            end
+            
+            it "should initialize with a clear internal state if the state file does not contain valid YAML" do
+                @state_file.write(:booness)
+                @state_file.flush()
+
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+                Puppet::Util::Storage.state().should == {}
+            end
+
+            it "should raise an error if the state file does not contain valid YAML and cannot be renamed" do
+                @state_file.write(:booness)
+                @state_file.flush()
+                YAML.expects(:load).raises(Puppet::Error)
+                File.expects(:rename).raises(SystemCallError)
+
+                proc { Puppet::Util::Storage.load() }.should raise_error()
+            end
+
+            it "should attempt to rename the state file if the file is corrupted" do
+                # We fake corruption by causing YAML.load to raise an exception
+                YAML.expects(:load).raises(Puppet::Error)
+                File.expects(:rename).at_least_once
+
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+            end
+
+            it "should fail gracefully on load() if the state file is not a regular file" do
+                @state_file.close!()
+                Dir.mkdir(Puppet[:statefile])
+                File.expects(:rename).returns(0)
+
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+
+                Dir.rmdir(Puppet[:statefile])
+            end
+
+            it "should fail gracefully on load() if it cannot get a read lock on the state file" do
+                Puppet::Util::FileLocking.expects(:readlock).yields(false)
+                test_yaml = {'File["/yayness"]'=>{"name"=>{:a=>:b,:c=>:d}}}
+                YAML.expects(:load).returns(test_yaml)
+
+                proc { Puppet::Util::Storage.load() }.should_not raise_error()
+                Puppet::Util::Storage.state().should == test_yaml
+            end
+            
+            after(:each) do
+                @state_file.close!()
+                Puppet[:statefile] = @saved_statefile
+            end
+        end
+    end
+
+    describe "when storing to the state file" do
+        before(:each) do
+            @state_file = Tempfile.new('storage_test')
+            @saved_statefile = Puppet[:statefile]
+            Puppet[:statefile] = @state_file.path()
+        end
+
+        it "should create the state file if it does not exist" do
+            @state_file.close!()
+            FileTest.exists?(Puppet[:statefile]).should be_false()
+            Puppet::Util::Storage.cache(:yayness)
+
+            proc { Puppet::Util::Storage.store() }.should_not raise_error()
+            FileTest.exists?(Puppet[:statefile]).should be_true()
+        end
+
+        it "should raise an exception if the state file is not a regular file" do
+            @state_file.close!()
+            Dir.mkdir(Puppet[:statefile])
+            Puppet::Util::Storage.cache(:yayness)
+
+            proc { Puppet::Util::Storage.store() }.should raise_error()
+
+            Dir.rmdir(Puppet[:statefile])
+        end
+
+        it "should raise an exception if it cannot get a write lock on the state file" do
+            Puppet::Util::FileLocking.expects(:writelock).yields(false)
+            Puppet::Util::Storage.cache(:yayness)
+
+            proc { Puppet::Util::Storage.store() }.should raise_error()
+        end
+
+        it "should load() the same information that it store()s" do
+            Puppet::Util::Storage.cache(:yayness)
+
+            Puppet::Util::Storage.state().should == {:yayness=>{}}
+            proc { Puppet::Util::Storage.store() }.should_not raise_error()
+            Puppet::Util::Storage.clear()
+            Puppet::Util::Storage.state().should == {}
+            proc { Puppet::Util::Storage.load() }.should_not raise_error()
+            Puppet::Util::Storage.state().should == {:yayness=>{}}
+        end
+
+        after(:each) do
+            @state_file.close!()
+            Puppet[:statefile] = @saved_statefile
+        end
+    end
+end

data/spec/unit/util/tagging.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-01-19.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/tagging'
+
+describe Puppet::Util::Tagging, "when adding tags" do
+    before do
+        @tagger = Object.new
+        @tagger.extend(Puppet::Util::Tagging)
+    end
+
+    it "should have a method for adding tags" do
+        @tagger.should be_respond_to(:tag)
+    end
+
+    it "should have a method for returning all tags" do
+        @tagger.should be_respond_to(:tags)
+    end
+
+    it "should add tags to the returned tag list" do
+        @tagger.tag("one")
+        @tagger.tags.should be_include("one")
+    end
+
+    it "should not add duplicate tags to the returned tag list" do
+        @tagger.tag("one")
+        @tagger.tag("one")
+        @tagger.tags.should == ["one"]
+    end
+
+    it "should return a duplicate of the tag list, rather than the original" do
+        @tagger.tag("one")
+        tags = @tagger.tags
+        tags << "two"
+        @tagger.tags.should_not be_include("two")
+    end
+
+    it "should add all provided tags to the tag list" do
+        @tagger.tag("one", "two")
+        @tagger.tags.should be_include("one")
+        @tagger.tags.should be_include("two")
+    end
+
+    it "should fail on tags containing '*' characters" do
+        lambda { @tagger.tag("bad*tag") }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should fail on tags starting with '-' characters" do
+        lambda { @tagger.tag("-badtag") }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should fail on tags containing ' ' characters" do
+        lambda { @tagger.tag("bad tag") }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should allow alpha tags" do
+        lambda { @tagger.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
+    end
+
+    it "should allow tags containing '.' characters" do
+        lambda { @tagger.tag("good.tag") }.should_not raise_error(Puppet::ParseError)
+    end
+
+    it "should provide a method for testing tag validity" do
+        @tagger.metaclass.publicize_methods(:valid_tag?)  { @tagger.should be_respond_to(:valid_tag?) }
+    end
+
+    it "should add qualified classes as tags" do
+        @tagger.tag("one::two")
+        @tagger.tags.should be_include("one::two")
+    end
+
+    it "should add each part of qualified classes as tags" do
+        @tagger.tag("one::two::three")
+        @tagger.tags.should be_include("one")
+        @tagger.tags.should be_include("two")
+        @tagger.tags.should be_include("three")
+    end
+
+    it "should indicate when the object is tagged with a provided tag" do
+        @tagger.tag("one")
+        @tagger.should be_tagged("one")
+    end
+
+    it "should indicate when the object is not tagged with a provided tag" do
+        @tagger.should_not be_tagged("one")
+    end
+end

data/spec/unit/util/uri_helper.rb

@@ -0,0 +1,41 @@
+#!/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/util/uri_helper'
+
+describe Puppet::Util::URIHelper, " when converting a key to a URI" do
+    before do
+        @helper = Object.new
+        @helper.extend(Puppet::Util::URIHelper)
+    end
+
+    it "should return the URI instance" do
+        URI.expects(:parse).with("file:///myhost/blah").returns(:myuri)
+        @helper.key2uri("/myhost/blah").should == :myuri
+    end
+
+    it "should escape the key before parsing" do
+        URI.expects(:escape).with("mykey").returns("http://myhost/blah")
+        URI.expects(:parse).with("http://myhost/blah").returns(:myuri)
+        @helper.key2uri("mykey").should == :myuri
+    end
+
+    it "should use the URI class to parse the key" do
+        URI.expects(:parse).with("http://myhost/blah").returns(:myuri)
+        @helper.key2uri("http://myhost/blah").should == :myuri
+    end
+
+    it "should set the scheme to 'file' if the key is a fully qualified path" do
+        URI.expects(:parse).with("file:///myhost/blah").returns(:myuri)
+        @helper.key2uri("/myhost/blah").should == :myuri
+    end
+
+    it "should set the host to 'nil' if the key is a fully qualified path" do
+        URI.expects(:parse).with("file:///myhost/blah").returns(:myuri)
+        @helper.key2uri("/myhost/blah").should == :myuri
+    end
+end

data/spec/unit/util/user_attr.rb

@@ -0,0 +1,47 @@
+#!/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/user_attr'
+
+describe UserAttr do
+    before do
+        user_attr = ["foo::::type=role", "bar::::type=normal;profile=foobar"]
+        File.stubs(:readlines).returns(user_attr)
+    end
+
+    describe "when getting attributes by name" do
+        it "should return nil if there is no entry for that name" do
+            UserAttr.get_attributes_by_name('baz').should == nil
+        end
+
+        it "should return a hash if there is an entry in /etc/user_attr" do
+            UserAttr.get_attributes_by_name('foo').class.should == Hash
+        end
+
+        it "should return a hash with the name value from /etc/user_attr" do
+             UserAttr.get_attributes_by_name('foo')[:name].should == 'foo'
+        end
+
+        #this test is contrived
+        #there are a bunch of possible parameters that could be in the hash
+        #the role/normal is just a the convention of the file
+        describe "when the name is a role" do
+            it "should contain :type = role" do
+                UserAttr.get_attributes_by_name('foo')[:type].should == 'role'
+            end
+        end
+
+        describe "when the name is not a role" do
+            it "should contain :type = normal" do
+                UserAttr.get_attributes_by_name('bar')[:type].should == 'normal'
+            end
+        end
+
+        describe "when the name has more attributes" do
+            it "should contain all the attributes" do
+                UserAttr.get_attributes_by_name('bar')[:profile].should == 'foobar'
+            end
+        end
+    end
+end

data/spec/unit/util/warnings.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Util::Warnings, " when registering a warning message" do
+    before(:all) do
+        @msg1 = "booness"
+        @msg2 = "more booness"
+    end
+
+    it "should always return nil" do
+        Puppet::Util::Warnings.warnonce(@msg1).should be(nil)
+    end
+
+    it "should issue a warning" do
+        Puppet.expects(:warning).with(@msg1)
+        Puppet::Util::Warnings.warnonce(@msg1)
+    end
+
+    it "should issue a warning exactly once per unique message" do
+        Puppet.expects(:warning).with(@msg1).once
+        Puppet::Util::Warnings.warnonce(@msg1)
+        Puppet::Util::Warnings.warnonce(@msg1)
+    end
+
+    it "should issue multiple warnings for multiple unique messages" do
+        Puppet.expects(:warning).times(2)
+        Puppet::Util::Warnings.warnonce(@msg1)
+        Puppet::Util::Warnings.warnonce(@msg2)
+    end
+
+    after(:each) do
+        Puppet::Util::Warnings.clear_warnings()
+    end
+end