puppet 0.24.6 → 0.24.7

data/spec/unit/type/zone.rb

@@ -0,0 +1,20 @@
+#!/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") }
+
+zone = Puppet::Type.type(:zone)
+
+describe zone do
+    before do
+        @provider = stub 'provider'
+        @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
+    end
+
+    parameters = [:create_args, :install_args]
+
+    parameters.each do |parameter|
+        it "should have a %s parameter" % parameter do
+            zone.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
+        end
+    end
+end

data/spec/unit/type/zpool.rb

@@ -0,0 +1,110 @@
+#!/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") }
+
+zpool = Puppet::Type.type(:zpool)
+
+describe zpool do
+    before do
+        @provider = stub 'provider'
+        @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
+    end
+
+    properties = [:ensure, :disk, :mirror, :raidz, :spare, :log]
+
+    properties.each do |property|
+        it "should have a %s property" % property do
+            zpool.attrclass(property).ancestors.should be_include(Puppet::Property)
+        end
+    end
+
+    parameters = [:pool, :raid_parity]
+
+    parameters.each do |parameter|
+        it "should have a %s parameter" % parameter do
+            zpool.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
+        end
+    end
+end
+
+vdev_property = Puppet::Property::VDev
+
+describe vdev_property do
+    before do
+        vdev_property.initvars
+        @resource = stub 'resource', :[]= => nil, :property => nil
+        @property = vdev_property.new(:resource => @resource)
+    end
+
+    it "should be insync if the devices are the same" do
+        @property.should = ["dev1 dev2"]
+        @property.insync?(["dev2 dev1"]).must be_true
+    end
+
+    it "should be out of sync if the devices are not the same" do
+        @property.should = ["dev1 dev3"]
+        @property.insync?(["dev2 dev1"]).must be_false
+    end
+
+    it "should be insync if the devices are the same and the should values are comma seperated" do
+        @property.should = ["dev1", "dev2"]
+        @property.insync?(["dev2 dev1"]).must be_true
+    end
+
+    it "should be out of sync if the device is absent and should has a value" do
+        @property.should = ["dev1", "dev2"]
+        @property.insync?(:absent).must be_false
+    end
+
+    it "should be insync if the device is absent and should is absent" do
+        @property.should = [:absent]
+        @property.insync?(:absent).must be_true
+    end
+end
+
+multi_vdev_property = Puppet::Property::MultiVDev
+
+describe multi_vdev_property do
+    before do
+        multi_vdev_property.initvars
+        @resource = stub 'resource', :[]= => nil, :property => nil
+        @property = multi_vdev_property.new(:resource => @resource)
+    end
+
+    it "should be insync if the devices are the same" do
+        @property.should = ["dev1 dev2"]
+        @property.insync?(["dev2 dev1"]).must be_true
+    end
+
+    it "should be out of sync if the devices are not the same" do
+        @property.should = ["dev1 dev3"]
+        @property.insync?(["dev2 dev1"]).must be_false
+    end
+
+    it "should be out of sync if the device is absent and should has a value" do
+        @property.should = ["dev1", "dev2"]
+        @property.insync?(:absent).must be_false
+    end
+
+    it "should be insync if the device is absent and should is absent" do
+        @property.should = [:absent]
+        @property.insync?(:absent).must be_true
+    end
+
+    describe "when there are multiple lists of devices" do
+        it "should be in sync if each group has the same devices" do
+            @property.should = ["dev1 dev2", "dev3 dev4"]
+            @property.insync?(["dev2 dev1", "dev3 dev4"]).must be_true
+        end
+
+        it "should be out of sync if any group has the different devices" do
+            @property.should = ["dev1 devX", "dev3 dev4"]
+            @property.insync?(["dev2 dev1", "dev3 dev4"]).must be_false
+        end
+
+        it "should be out of sync if devices are in the wrong group" do
+            @property.should = ["dev1 dev2", "dev3 dev4"]
+            @property.insync?(["dev2 dev3", "dev1 dev4"]).must be_false
+        end
+    end
+end

data/spec/unit/util/checksums.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/checksums'
+
+describe Puppet::Util::Checksums do
+    before do
+        @summer = Object.new
+        @summer.extend(Puppet::Util::Checksums)
+    end
+
+    content_sums = [:md5, :md5lite, :sha1, :sha1lite]
+    file_only = [:ctime, :mtime]
+
+    content_sums.each do |sumtype|
+        it "should be able to calculate %s sums from strings" % sumtype do
+            @summer.should be_respond_to(sumtype)
+        end
+    end
+
+    [content_sums, file_only].flatten.each do |sumtype|
+        it "should be able to calculate %s sums from files" % sumtype do
+            @summer.should be_respond_to(sumtype.to_s + "_file")
+        end
+    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
+                klass.expects(:hexdigest).with("mycontent").returns "whatever"
+                @summer.send(sum, "mycontent").should == "whatever"
+            end
+
+            it "should use incremental #{klass} sums to calculate file checksums" do
+                digest = mock 'digest'
+                klass.expects(:new).returns digest
+
+                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(512).returns("secondline")
+                #fh.expects(:read).with(512).returns(nil)
+
+                File.expects(:open).with(file, "r").yields(fh)
+
+                digest.expects(:<<).with "firstline"
+                digest.expects(:<<).with "secondline"
+                digest.expects(:hexdigest).returns :mydigest
+
+                @summer.send(sum.to_s + "_file", file).should == :mydigest
+            end
+        end
+    end
+
+    {:md5lite => Digest::MD5, :sha1lite => Digest::SHA1}.each do |sum, klass|
+        describe("when using %s" % sum) do
+            it "should use #{klass} to calculate string checksums from the first 512 characters of the string" do
+                content = "this is a test" * 100
+                klass.expects(:hexdigest).with(content[0..511]).returns "whatever"
+                @summer.send(sum, content).should == "whatever"
+            end
+
+            it "should use #{klass} to calculate a sum from the first 512 characters in the file" do
+                digest = mock 'digest'
+                klass.expects(:new).returns digest
+
+                file = "/path/to/my/file"
+
+                fh = mock 'filehandle'
+                fh.expects(:read).with(512).returns('my content')
+
+                File.expects(:open).with(file, "r").yields(fh)
+
+                digest.expects(:<<).with "my content"
+                digest.expects(:hexdigest).returns :mydigest
+
+                @summer.send(sum.to_s + "_file", file).should == :mydigest
+            end
+        end
+    end
+
+    [:ctime, :mtime].each do |sum|
+        describe("when using %s" % sum) do
+            it "should use the '#{sum}' on the file to determine the ctime" do
+                file = "/my/file"
+                stat = mock 'stat', sum => "mysum"
+
+                File.expects(:stat).with(file).returns(stat)
+
+                @summer.send(sum.to_s + "_file", file).should == "mysum"
+            end
+        end
+    end
+end

data/spec/unit/util/constant_inflector.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-02-12.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/constant_inflector'
+
+describe Puppet::Util::ConstantInflector, "when converting file names to constants" do
+    before do
+        @inflector = Object.new
+        @inflector.extend(Puppet::Util::ConstantInflector)
+    end
+
+    it "should capitalize terms" do
+        @inflector.file2constant("file").should == "File"
+    end
+
+    it "should switch all '/' characters to double colons" do
+        @inflector.file2constant("file/other").should == "File::Other"
+    end
+
+    it "should remove underscores and capitalize the proceeding letter" do
+        @inflector.file2constant("file_other").should == "FileOther"
+    end
+
+    it "should correctly replace as many underscores as exist in the file name" do
+        @inflector.file2constant("two_under_scores/with_some_more_underscores").should == "TwoUnderScores::WithSomeMoreUnderscores"
+    end
+
+    it "should collapse multiple underscores" do
+        @inflector.file2constant("many___scores").should == "ManyScores"
+    end
+
+    it "should correctly handle file names deeper than two directories" do
+        @inflector.file2constant("one_two/three_four/five_six").should == "OneTwo::ThreeFour::FiveSix"
+    end
+end
+
+describe Puppet::Util::ConstantInflector, "when converting constnats to file names" do
+    before do
+        @inflector = Object.new
+        @inflector.extend(Puppet::Util::ConstantInflector)
+    end
+
+    it "should convert them to a string if necessary" do
+        @inflector.constant2file(Puppet::Util::ConstantInflector).should be_instance_of(String)
+    end
+
+    it "should accept string inputs" do
+        @inflector.constant2file("Puppet::Util::ConstantInflector").should be_instance_of(String)
+    end
+
+    it "should downcase all terms" do
+        @inflector.constant2file("Puppet").should == "puppet"
+    end
+
+    it "should convert '::' to '/'" do
+        @inflector.constant2file("Puppet::Util::Constant").should == "puppet/util/constant"
+    end
+
+    it "should convert mid-word capitalization to an underscore" do
+        @inflector.constant2file("OneTwo::ThreeFour").should == "one_two/three_four"
+    end
+
+    it "should correctly handle constants with more than two parts" do
+        @inflector.constant2file("OneTwoThree::FourFiveSixSeven").should == "one_two_three/four_five_six_seven"
+    end
+end

data/spec/unit/util/file_locking.rb

@@ -0,0 +1,115 @@
+#!/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/file_locking'
+
+class FileLocker
+    include Puppet::Util::FileLocking
+end
+
+describe Puppet::Util::FileLocking do
+    it "should have a module method for getting a read lock on files" do
+        Puppet::Util::FileLocking.should respond_to(:readlock)
+    end
+
+    it "should have a module method for getting a write lock on files" do
+        Puppet::Util::FileLocking.should respond_to(:writelock)
+    end
+
+    it "should have an instance method for getting a read lock on files" do
+        FileLocker.new.private_methods.should be_include("readlock")
+    end
+
+    it "should have an instance method for getting a write lock on files" do
+        FileLocker.new.private_methods.should be_include("writelock")
+    end
+
+    describe "when acquiring a read lock" do
+        it "should use a global shared mutex" do
+            sync = mock 'sync'
+            sync.expects(:synchronize).with(Sync::SH)
+            Puppet::Util.expects(:sync).with("/file").returns sync
+
+            Puppet::Util::FileLocking.readlock '/file'
+        end
+
+        it "should use a shared lock on the file" do
+            sync = mock 'sync'
+            sync.expects(:synchronize).yields
+            Puppet::Util.expects(:sync).with("/file").returns sync
+
+            fh = mock 'filehandle'
+            File.expects(:open).with("/file").yields fh
+            fh.expects(:lock_shared).yields "locked_fh"
+
+            result = nil
+            Puppet::Util::FileLocking.readlock('/file') { |l| result = l }
+            result.should == "locked_fh"
+        end
+    end
+
+    describe "when acquiring a write lock" do
+        before do
+            @sync = mock 'sync'
+            Puppet::Util.stubs(:sync).returns @sync
+            @sync.stubs(:synchronize).yields
+        end
+
+        it "should fail if the parent directory does not exist" do
+            FileTest.expects(:directory?).with("/my/dir").returns false
+
+            lambda { Puppet::Util::FileLocking.writelock('/my/dir/file') }.should raise_error(Puppet::DevError)
+        end
+
+        it "should use a global exclusive mutex" do
+            sync = mock 'sync'
+            sync.expects(:synchronize).with(Sync::EX)
+            Puppet::Util.expects(:sync).with("/file").returns sync
+
+            Puppet::Util::FileLocking.writelock '/file'
+        end
+
+        it "should use any specified mode when opening the file" do
+            File.expects(:open).with("/file", "w", :mymode)
+
+            Puppet::Util::FileLocking.writelock('/file', :mymode)
+        end
+
+        it "should use the mode of the existing file if no mode is specified" do
+            File.expects(:stat).with("/file").returns(mock("stat", :mode => 0755))
+            File.expects(:open).with("/file", "w", 0755)
+
+            Puppet::Util::FileLocking.writelock('/file')
+        end
+
+        it "should use 0600 as the mode if no mode is specified and the file does not exist" do
+            File.expects(:stat).raises(Errno::ENOENT)
+            File.expects(:open).with("/file", "w", 0600)
+
+            Puppet::Util::FileLocking.writelock('/file')
+        end
+
+        it "should create an exclusive file lock" do
+            fh = mock 'fh'
+            File.expects(:open).yields fh
+            fh.expects(:lock_exclusive)
+
+            Puppet::Util::FileLocking.writelock('/file')
+        end
+
+        it "should allow the caller to write to the locked file" do
+            fh = mock 'fh'
+            File.expects(:open).yields fh
+
+            lfh = mock 'locked_filehandle'
+            fh.expects(:lock_exclusive).yields(lfh)
+
+            lfh.expects(:print).with "foo"
+
+            Puppet::Util::FileLocking.writelock('/file') do |f|
+                f.print "foo"
+            end
+        end
+    end
+end

data/spec/unit/util/ldap/connection.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-19.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/util/ldap/connection'
+
+# So our mocks and such all work, even when ldap isn't available.
+unless defined?(LDAP::Conn)
+    class LDAP
+        class Conn
+            def initialize(*args)
+            end
+        end
+        class SSLConn < Conn; end
+
+        LDAP_OPT_PROTOCOL_VERSION = 1
+        LDAP_OPT_REFERRALS = 2
+        LDAP_OPT_ON = 3
+    end
+end
+
+describe Puppet::Util::Ldap::Connection do
+    before do
+        Puppet.features.stubs(:ldap?).returns true
+
+        @ldapconn = mock 'ldap'
+        LDAP::Conn.stubs(:new).returns(@ldapconn)
+        LDAP::SSLConn.stubs(:new).returns(@ldapconn)
+
+        @ldapconn.stub_everything
+
+        @connection = Puppet::Util::Ldap::Connection.new("host", "port")
+    end
+
+
+    describe "when creating connections" do
+        it "should require the host and port" do
+            lambda { Puppet::Util::Ldap::Connection.new("myhost") }.should raise_error(ArgumentError)
+        end
+
+        it "should allow specification of a user and password" do
+            lambda { Puppet::Util::Ldap::Connection.new("myhost", "myport", :user => "blah", :password => "boo") }.should_not raise_error
+        end
+
+        it "should allow specification of ssl" do
+            lambda { Puppet::Util::Ldap::Connection.new("myhost", "myport", :ssl => :tsl) }.should_not raise_error
+        end
+
+        it "should support requiring a new connection" do
+            lambda { Puppet::Util::Ldap::Connection.new("myhost", "myport", :reset => true) }.should_not raise_error
+        end
+
+        it "should fail if ldap is unavailable" do
+            Puppet.features.expects(:ldap?).returns(false)
+
+            lambda { Puppet::Util::Ldap::Connection.new("host", "port") }.should raise_error(Puppet::Error)
+        end
+
+        it "should use neither ssl nor tls by default" do
+            LDAP::Conn.expects(:new).with("host", "port").returns(@ldapconn)
+
+            @connection.start
+        end
+
+        it "should use LDAP::SSLConn if ssl is requested" do
+            LDAP::SSLConn.expects(:new).with("host", "port").returns(@ldapconn)
+
+            @connection.ssl = true
+
+            @connection.start
+        end
+
+        it "should use LDAP::SSLConn and tls if tls is requested" do
+            LDAP::SSLConn.expects(:new).with("host", "port", true).returns(@ldapconn)
+
+            @connection.ssl = :tls
+
+            @connection.start
+        end
+
+        it "should set the protocol version to 3 and enable referrals" do
+            @ldapconn.expects(:set_option).with(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
+            @ldapconn.expects(:set_option).with(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
+            @connection.start
+        end
+
+        it "should bind with the provided user and password" do
+            @connection.user = "myuser"
+            @connection.password = "mypassword"
+            @ldapconn.expects(:simple_bind).with("myuser", "mypassword")
+
+            @connection.start
+        end
+
+        it "should bind with no user and password if none has been provided" do
+            @ldapconn.expects(:simple_bind).with(nil, nil)
+            @connection.start
+        end
+    end
+
+    describe "when closing connections" do
+        it "should not close connections that are not open" do
+            @connection.stubs(:connection).returns(@ldapconn)
+
+            @ldapconn.expects(:bound?).returns false
+            @ldapconn.expects(:unbind).never
+
+            @connection.close
+        end
+    end
+
+    it "should have a class-level method for creating a default connection" do
+        Puppet::Util::Ldap::Connection.should respond_to(:instance)
+    end
+
+    describe "when creating a default connection" do
+        before do
+            Puppet.settings.stubs(:value).returns "whatever"
+        end
+
+        it "should use the :ldapserver setting to determine the host" do
+            Puppet.settings.expects(:value).with(:ldapserver).returns "myserv"
+            Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| host == "myserv" }
+            Puppet::Util::Ldap::Connection.instance
+        end
+
+        it "should use the :ldapport setting to determine the port" do
+            Puppet.settings.expects(:value).with(:ldapport).returns "456"
+            Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| port == "456" }
+            Puppet::Util::Ldap::Connection.instance
+        end
+
+        it "should set ssl to :tls if tls is enabled" do
+            Puppet.settings.expects(:value).with(:ldaptls).returns true
+            Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:ssl] == :tls }
+            Puppet::Util::Ldap::Connection.instance
+        end
+
+        it "should set ssl to 'true' if ssl is enabled and tls is not" do
+            Puppet.settings.expects(:value).with(:ldaptls).returns false
+            Puppet.settings.expects(:value).with(:ldapssl).returns true
+            Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:ssl] == true }
+            Puppet::Util::Ldap::Connection.instance
+        end
+
+        it "should set ssl to false if neither ssl nor tls are enabled" do
+            Puppet.settings.expects(:value).with(:ldaptls).returns false
+            Puppet.settings.expects(:value).with(:ldapssl).returns false
+            Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:ssl] == false }
+            Puppet::Util::Ldap::Connection.instance
+        end
+
+        it "should set the ldapuser if one is set" do
+            Puppet.settings.expects(:value).with(:ldapuser).returns "foo"
+            Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:user] == "foo" }
+            Puppet::Util::Ldap::Connection.instance
+        end
+
+        it "should set the ldapuser and ldappassword if both is set" do
+            Puppet.settings.expects(:value).with(:ldapuser).returns "foo"
+            Puppet.settings.expects(:value).with(:ldappassword).returns "bar"
+            Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:user] == "foo" and options[:password] == "bar" }
+            Puppet::Util::Ldap::Connection.instance
+        end
+    end
+end