puppet 0.25.5 → 2.6.0

data/spec/unit/util/errors_spec.rb

@@ -0,0 +1,38 @@
+#!/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/errors'
+
+class ErrorTester
+  include Puppet::Util::Errors
+  attr_accessor :line, :file
+end
+
+describe Puppet::Util::Errors do
+  before do
+    @tester = ErrorTester.new
+  end
+
+  it "should provide a 'fail' method" do
+    @tester.should respond_to(:fail)
+  end
+
+  it "should provide a 'devfail' method" do
+    @tester.should respond_to(:devfail)
+  end
+
+  it "should raise any provided error when failing" do
+    lambda { @tester.fail(Puppet::ParseError, "stuff") }.should raise_error(Puppet::ParseError)
+  end
+
+  it "should default to Puppet::Error when failing" do
+    lambda { @tester.fail("stuff") }.should raise_error(Puppet::Error)
+  end
+
+  it "should have a method for converting error context into a string" do
+    @tester.file = "/my/file"
+    @tester.line = 50
+    @tester.error_context.should == " at /my/file:50"
+  end
+end

data/spec/unit/util/feature_spec.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/file_locking_spec.rb

@@ -0,0 +1,156 @@
+#!/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
+    before do
+      File.stubs(:exists?).with('/file').returns true
+      File.stubs(:file?).with('/file').returns true
+    end
+
+    it "should use a global shared mutex" do
+      @sync = mock 'sync'
+      @sync.expects(:synchronize).with(Sync::SH).once
+      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.stubs(: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
+
+    it "should only work on regular files" do
+      File.expects(:file?).with('/file').returns false
+      proc { Puppet::Util::FileLocking.readlock('/file') }.should raise_error(ArgumentError)
+    end
+
+    it "should create missing files" do
+      @sync = mock 'sync'
+      @sync.stubs(:synchronize).yields
+      Puppet::Util.expects(:sync).with('/file').returns @sync
+
+      File.expects(:exists?).with('/file').returns false
+      File.expects(:open).with('/file').once
+
+      Puppet::Util::FileLocking.readlock('/file')
+    end
+  end
+
+  describe "when acquiring a write lock" do
+    before do
+      @sync = mock 'sync'
+      Puppet::Util.stubs(:sync).returns @sync
+      @sync.stubs(:synchronize).yields
+      File.stubs(:file?).with('/file').returns true
+      File.stubs(:exists?).with('/file').returns true
+    end
+
+    it "should fail if the parent directory does not exist" do
+      FileTest.expects(:directory?).with("/my/dir").returns false
+      File.stubs(:file?).with('/my/dir/file').returns true
+      File.stubs(:exists?).with('/my/dir/file').returns true
+
+      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
+
+    it "should only work on regular files" do
+      File.expects(:file?).with('/file').returns false
+      proc { Puppet::Util::FileLocking.writelock('/file') }.should raise_error(ArgumentError)
+    end
+
+    it "should create missing files" do
+      @sync = mock 'sync'
+      @sync.stubs(:synchronize).yields
+      Puppet::Util.expects(:sync).with('/file').returns @sync
+
+      File.expects(:exists?).with('/file').returns false
+      File.expects(:open).with('/file', 'w', 0600).once
+
+      Puppet::Util::FileLocking.writelock('/file')
+    end
+  end
+end

data/spec/unit/util/filetype_spec.rb

@@ -0,0 +1,100 @@
+#!/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/filetype'
+
+# XXX Import all of the tests into this file.
+describe Puppet::Util::FileType do
+  describe "when backing up a file" do
+    before do
+      @file = Puppet::Util::FileType.filetype(:flat).new("/my/file")
+    end
+
+    it "should do nothing if the file does not exist" do
+      File.expects(:exists?).with("/my/file").returns false
+      @file.expects(:bucket).never
+      @file.backup
+    end
+
+    it "should use its filebucket to backup the file if it exists" do
+      File.expects(:exists?).with("/my/file").returns true
+
+      bucket = mock 'bucket'
+      bucket.expects(:backup).with("/my/file")
+
+      @file.expects(:bucket).returns bucket
+      @file.backup
+    end
+
+    it "should use the default filebucket" do
+      bucket = mock 'bucket'
+      bucket.expects(:bucket).returns "mybucket"
+
+      Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
+
+      @file.bucket.should == "mybucket"
+    end
+  end
+
+  describe "the flat filetype" do
+    before do
+      @type = Puppet::Util::FileType.filetype(:flat)
+    end
+    it "should exist" do
+      @type.should_not be_nil
+    end
+
+    describe "when the file already exists" do
+      it "should return the file's contents when asked to read it" do
+        file = @type.new("/my/file")
+        File.expects(:exist?).with("/my/file").returns true
+        File.expects(:read).with("/my/file").returns "my text"
+
+        file.read.should == "my text"
+      end
+
+      it "should unlink the file when asked to remove it" do
+        file = @type.new("/my/file")
+        File.expects(:exist?).with("/my/file").returns true
+        File.expects(:unlink).with("/my/file")
+
+        file.remove
+      end
+    end
+
+    describe "when the file does not exist" do
+      it "should return an empty string when asked to read the file" do
+        file = @type.new("/my/file")
+        File.expects(:exist?).with("/my/file").returns false
+
+        file.read.should == ""
+      end
+    end
+
+    describe "when writing the file" do
+      before do
+        @file = @type.new("/my/file")
+        FileUtils.stubs(:cp)
+
+        @tempfile = stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file"
+        Tempfile.stubs(:new).returns @tempfile
+      end
+
+      it "should first create a temp file and copy its contents over to the file location" do
+        Tempfile.expects(:new).with("puppet").returns @tempfile
+        @tempfile.expects(:print).with("my text")
+        @tempfile.expects(:flush)
+        @tempfile.expects(:close)
+        FileUtils.expects(:cp).with(@tempfile.path, "/my/file")
+
+        @file.write "my text"
+      end
+
+      it "should set the selinux default context on the file" do
+        @file.expects(:set_selinux_default_context).with("/my/file")
+        @file.write "eh"
+      end
+    end
+  end
+end

data/spec/unit/util/inline_docs_spec.rb

@@ -0,0 +1,32 @@
+#!/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/inline_docs'
+
+class InlineDoccer
+  include Puppet::Util::InlineDocs
+end
+
+describe Puppet::Util::InlineDocs do
+  describe "when included" do
+    it "should create a class method for specifying that docs should be associated" do
+      InlineDoccer.expects(:use_docs=).with true
+      InlineDoccer.associates_doc
+    end
+
+    it "should default to not associating docs" do
+      (!! InlineDoccer.use_docs).should be_false
+    end
+
+    it "should create an instance method for setting documentation" do
+      instance = InlineDoccer.new
+      instance.doc = "foo"
+      instance.doc.should == "foo"
+    end
+
+    it "should default to an empty string for docs" do
+      InlineDoccer.new.doc.should == ""
+    end
+  end
+end

data/spec/unit/util/json_spec.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/pson'
+
+class PsonUtil
+  include Puppet::Util::Pson
+end
+
+describe Puppet::Util::Pson do
+  it "should fail if no data is provided" do
+    lambda { PsonUtil.new.pson_create("type" => "foo") }.should raise_error(ArgumentError)
+  end
+
+  it "should call 'from_pson' with the provided data" do
+    pson = PsonUtil.new
+    pson.expects(:from_pson).with("mydata")
+    pson.pson_create("type" => "foo", "data" => "mydata")
+  end
+end

data/spec/unit/util/ldap/connection_spec.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 Puppet.features.ldap?
+  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