puppet 0.24.9 → 0.25.0

data/spec/unit/util/settings/file_setting.rb

@@ -0,0 +1,223 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/util/settings'
+require 'puppet/util/settings/file_setting'
+
+describe Puppet::Util::Settings::FileSetting do
+    FileSetting = Puppet::Util::Settings::FileSetting
+
+    describe "when determining whether the service user should be used" do
+        before do
+            @settings = mock 'settings'
+            @settings.stubs(:[]).with(:mkusers).returns false
+            @settings.stubs(:service_user_available?).returns true
+        end
+
+        it "should be true if the service user is available" do
+            @settings.expects(:service_user_available?).returns true
+            setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
+            setting.should be_use_service_user
+        end
+
+        it "should be true if 'mkusers' is set" do
+            @settings.expects(:[]).with(:mkusers).returns true
+            setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
+            setting.should be_use_service_user
+        end
+
+        it "should be false if the service user is not available and 'mkusers' is unset" do
+            setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
+            setting.should be_use_service_user
+        end
+    end
+
+    describe "when setting the owner" do
+        it "should allow the file to be owned by root" do
+            root_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting") }
+            root_owner.should_not raise_error
+        end
+
+        it "should allow the file to be owned by the service user" do
+            service_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "service", :desc => "a setting") }
+            service_owner.should_not raise_error
+        end
+
+        it "should allow the ownership of the file to be unspecified" do
+            no_owner = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
+            no_owner.should_not raise_error
+        end
+
+        it "should not allow other owners" do
+            invalid_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "invalid", :desc => "a setting") }
+            invalid_owner.should raise_error(FileSetting::SettingError)
+        end
+    end
+
+    describe "when reading the owner" do
+        it "should be root when the setting specifies root" do
+            setting = FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting") 
+            setting.owner.should == "root"
+        end
+
+        it "should be the owner of the service when the setting specifies service and the service user should be used" do
+            settings = mock("settings")
+            settings.stubs(:[]).returns "the_service"
+
+            setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
+            setting.expects(:use_service_user?).returns true
+            setting.owner.should == "the_service"
+        end
+
+        it "should be the root when the setting specifies service and the service user should not be used" do
+            settings = mock("settings")
+            settings.stubs(:[]).returns "the_service"
+
+            setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
+            setting.expects(:use_service_user?).returns false
+            setting.owner.should == "root"
+        end
+
+        it "should be nil when the owner is unspecified" do
+            FileSetting.new(:settings => mock("settings"), :desc => "a setting").owner.should be_nil
+        end
+    end
+
+    describe "when setting the group" do
+        it "should allow the group to be service" do
+            service_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "service", :desc => "a setting") }
+            service_group.should_not raise_error
+        end
+
+        it "should allow the group to be unspecified" do
+            no_group = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
+            no_group.should_not raise_error
+        end
+
+        it "should not allow invalid groups" do
+            invalid_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "invalid", :desc => "a setting") }
+            invalid_group.should raise_error(FileSetting::SettingError)
+        end
+    end
+
+    describe "when reading the group" do
+        it "should be service when the setting specifies service" do
+            setting = FileSetting.new(:settings => mock("settings", :[] => "the_service"), :group => "service", :desc => "a setting")
+            setting.group.should == "the_service"
+        end
+
+        it "should be nil when the group is unspecified" do
+            FileSetting.new(:settings => mock("settings"), :desc => "a setting").group.should be_nil
+        end
+    end
+
+    it "should be able to be converted into a resource" do
+        FileSetting.new(:settings => mock("settings"), :desc => "eh").should respond_to(:to_resource)
+    end
+
+    describe "when being converted to a resource" do
+        before do
+            @settings = mock 'settings'
+            @file = Puppet::Util::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
+            @settings.stubs(:value).with(:mydir).returns "/my/file"
+        end
+
+        it "should skip files that cannot determine their types" do
+            @file.expects(:type).returns nil
+            @file.to_resource.should be_nil
+        end
+
+        it "should skip non-existent files if 'create_files' is not enabled" do
+            @file.expects(:create_files?).returns false
+            @file.expects(:type).returns :file
+            File.expects(:exist?).with("/my/file").returns false
+            @file.to_resource.should be_nil
+        end
+
+        it "should manage existent files even if 'create_files' is not enabled" do
+            @file.expects(:create_files?).returns false
+            @file.expects(:type).returns :file
+            File.expects(:exist?).with("/my/file").returns true
+            @file.to_resource.should be_instance_of(Puppet::Resource)
+        end
+
+        it "should skip files in /dev" do
+            @settings.stubs(:value).with(:mydir).returns "/dev/file"
+            @file.to_resource.should be_nil
+        end
+
+        it "should skip files whose paths are not strings" do
+            @settings.stubs(:value).with(:mydir).returns :foo
+            @file.to_resource.should be_nil
+        end
+
+        it "should return a file resource with the path set appropriately" do
+            resource = @file.to_resource
+            resource.type.should == "File"
+            resource.title.should == "/my/file"
+        end
+
+        it "should fully qualified returned files if necessary (#795)" do
+            @settings.stubs(:value).with(:mydir).returns "myfile"
+            @file.to_resource.title.should == File.join(Dir.getwd, "myfile")
+        end
+
+        it "should set the mode on the file if a mode is provided" do
+            @file.mode = 0755
+
+            @file.to_resource[:mode].should == 0755
+        end
+
+        it "should set the owner if running as root and the owner is provided" do
+            Puppet.features.expects(:root?).returns true
+            @file.stubs(:owner).returns "foo"
+            @file.to_resource[:owner].should == "foo"
+        end
+
+        it "should set the group if running as root and the group is provided" do
+            Puppet.features.expects(:root?).returns true
+            @file.stubs(:group).returns "foo"
+            @file.to_resource[:group].should == "foo"
+        end
+
+        it "should not set owner if not running as root" do
+            Puppet.features.expects(:root?).returns false
+            @file.stubs(:owner).returns "foo"
+            @file.to_resource[:owner].should be_nil
+        end
+
+        it "should not set group if not running as root" do
+            Puppet.features.expects(:root?).returns false
+            @file.stubs(:group).returns "foo"
+            @file.to_resource[:group].should be_nil
+        end
+
+        it "should set :ensure to the file type" do
+            @file.expects(:type).returns :directory
+            @file.to_resource[:ensure].should == :directory
+        end
+
+        it "should set the loglevel to :debug" do
+            @file.to_resource[:loglevel].should == :debug
+        end
+
+        it "should set the backup to false" do
+            @file.to_resource[:backup].should be_false
+        end
+
+        it "should tag the resource with the settings section" do
+            @file.expects(:section).returns "mysect"
+            @file.to_resource.should be_tagged("mysect")
+        end
+
+        it "should tag the resource with the setting name" do
+            @file.to_resource.should be_tagged("mydir")
+        end
+
+        it "should tag the resource with 'settings'" do
+            @file.to_resource.should be_tagged("settings")
+        end
+    end
+end
+

data/spec/unit/util/storage.rb

@@ -12,13 +12,13 @@ describe Puppet::Util::Storage do
         Puppet[:statedir] = Dir.tmpdir()
     end
 
+    after(:all) do
+        Puppet.settings.clear
+    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
@@ -41,8 +41,8 @@ describe Puppet::Util::Storage do
 
     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")
+            @file_test = Puppet::Type.type(:file).new(:name => "/yayness", :check => %w{checksum type})
+            @exec_test = Puppet::Type.type(:exec).new(:name => "/bin/ls /yayness")
         end
 
         it "should return an empty hash" do
@@ -99,7 +99,7 @@ describe Puppet::Util::Storage do
                 @path = transient.path()
                 transient.close!()
             end
-            
+
             it "should not fail to load()" do
                 FileTest.exists?(@path).should be_false()
                 Puppet[:statedir] = @path
@@ -113,10 +113,10 @@ describe Puppet::Util::Storage do
 
                 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
@@ -144,7 +144,7 @@ describe Puppet::Util::Storage do
                 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()
@@ -188,7 +188,7 @@ describe Puppet::Util::Storage do
                 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

data/spec/unit/util/warnings.rb

@@ -2,31 +2,35 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Puppet::Util::Warnings, " when registering a warning message" do
+describe Puppet::Util::Warnings 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
+    {:notice => "notice_once", :warning => "warnonce"}.each do |log, method|
+        describe "when registring '%s' messages" % log do
+            it "should always return nil" do
+                Puppet::Util::Warnings.send(method, @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" do
+                Puppet.expects(log).with(@msg1)
+                Puppet::Util::Warnings.send(method, @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 a warning exactly once per unique message" do
+                Puppet.expects(log).with(@msg1).once
+                Puppet::Util::Warnings.send(method, @msg1)
+                Puppet::Util::Warnings.send(method, @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)
+            it "should issue multiple warnings for multiple unique messages" do
+                Puppet.expects(log).times(2)
+                Puppet::Util::Warnings.send(method, @msg1)
+                Puppet::Util::Warnings.send(method, @msg2)
+            end
+        end
     end
 
     after(:each) do

data/test/Rakefile

@@ -55,7 +55,7 @@ end
 
 desc "Run the full test suite"
 Rake::PuppetTestTask.new :test do |t|
-    t.libs << $test_library_paths
+    t.libs += $test_library_paths
 
     # Add every file as a test file to run
     t.test_files = allfiles
@@ -72,16 +72,17 @@ filemap.each do |dir, files|
     namespace ns do
         files.each do |file|
             Rake::PuppetTestTask.new File.basename(file, '.rb').to_sym do |t|
-                t.libs << $test_library_paths + ['..']
+                t.libs += $test_library_paths + ['..']
+                t.libs << '..'
                 t.test_files = [ file ]
-                t.verbose = true 
-            end 
+                t.verbose = true
+            end
         end
     end
 
     # Then create a task that matches the directory itself.
     Rake::PuppetTestTask.new dir do |t|
-       t.libs << $test_library_paths
+       t.libs += $test_library_paths
        if ENV["TESTFILES"]
            t.test_files = ENV["TESTFILES"].split(/\s+/)
        else

data/test/certmgr/ca.rb

@@ -22,11 +22,11 @@ class TestCA < Test::Unit::TestCase
     def mkca
         Puppet::SSLCertificates::CA.new
     end
-    
+
     def test_clean
         dirs = [:csrdir, :signeddir, :publickeydir, :privatekeydir, :certdir]
         ca = mkca
-        
+
         hosts.each do |host|
             files = []
             dirs.each do |dir|
@@ -46,7 +46,7 @@ class TestCA < Test::Unit::TestCase
             end
         end
     end
-    
+
     def test_host2Xfile
         ca = mkca
         hosts.each do |host|
@@ -60,7 +60,7 @@ class TestCA < Test::Unit::TestCase
             end
         end
     end
-    
+
     def test_list
         ca = mkca
         # Make a fake csr
@@ -71,7 +71,7 @@ class TestCA < Test::Unit::TestCase
             File.open(file, "w") { |f| f.puts "yay" }
             list << host.downcase
         end
-        
+
         assert_equal(list.sort, ca.list.sort, "list was not correct")
     end
 

data/test/certmgr/certmgr.rb

@@ -164,7 +164,7 @@ class TestCertMgr < Test::Unit::TestCase
         assert_equal($?,0)
         assert_equal(File.join(Puppet[:certdir], "signedcertest.pem: OK\n"), output)
     end
- 
+
 
     def test_interactiveca
         ca = nil
@@ -224,14 +224,14 @@ class TestCertMgr < Test::Unit::TestCase
         ca = mkCA()
         h1 = mksignedcert(ca, "host1.example.com")
         h2 = mksignedcert(ca, "host2.example.com")
-        
+
         assert(ca.cert.verify(ca.cert.public_key))
         assert(h1.verify(ca.cert.public_key))
         assert(h2.verify(ca.cert.public_key))
 
         crl = ca.crl
         assert_not_nil(crl)
-        
+
         store = mkStore(ca)
         assert( store.verify(ca.cert))
         assert( store.verify(h1, [ca.cert]))
@@ -252,7 +252,7 @@ class TestCertMgr < Test::Unit::TestCase
         assert( store.verify(ca.cert), "Could not verify CA certs after reloading certs.")
         assert(!store.verify(h1, [ca.cert]), "Incorrectly verified revoked cert.")
         assert( store.verify(h2, [ca.cert]), "Could not verify certs with reloaded CA.")
-        
+
         ca.revoke(h2.serial)
         assert_equal(1, ca.crl.extensions.size)