openldap 0.0.1pre11

data/lib/openldap/mixins.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/ruby
+
+require 'rbconfig'
+require 'erb'
+require 'etc'
+require 'logger'
+
+require 'openldap'
+
+
+#--
+# A collection of mixins shared between OpenLDAP classes. Stolen mostly from ThingFish.
+#
+module OpenLDAP # :nodoc:
+
+	# Add logging to a OpenLDAP class. Including classes get #log and #log_debug methods.
+	module Loggable
+
+		LEVEL = {
+			:debug => Logger::DEBUG,
+			:info  => Logger::INFO,
+			:warn  => Logger::WARN,
+			:error => Logger::ERROR,
+			:fatal => Logger::FATAL,
+		  }
+
+		### A logging proxy class that wraps calls to the logger into calls that include
+		### the name of the calling class.
+		class ClassNameProxy # :nodoc:
+
+			### Create a new proxy for the given +klass+.
+			def initialize( klass, force_debug=false )
+				@classname   = klass.name
+				@force_debug = force_debug
+			end
+
+			### Delegate calls the global logger with the class name as the 'progname' 
+			### argument.
+			def method_missing( sym, msg=nil, &block )
+				return super unless LEVEL.key?( sym )
+				sym = :debug if @force_debug
+				OpenLDAP.logger.add( LEVEL[sym], msg, @classname, &block )
+			end
+		end # ClassNameProxy
+
+		#########
+		protected
+		#########
+
+		### Return the proxied logger.
+		def log
+			@log_proxy ||= ClassNameProxy.new( self.class )
+		end
+
+		### Return a proxied "debug" logger that ignores other level specification.
+		def log_debug
+			@log_debug_proxy ||= ClassNameProxy.new( self.class, true )
+		end
+	end # module Loggable
+
+
+end # module OpenLDAP
+
+# vim: set nosta noet ts=4 sw=4:
+

data/lib/openldap/utils.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require 'logger'
+require 'erb'
+
+require 'openldap' unless defined?( OpenLDAP )
+
+module OpenLDAP # :nodoc:
+
+	# A alternate formatter for Logger instances.
+	class LogFormatter < Logger::Formatter # :nodoc:
+
+		# The format to output unless debugging is turned on
+		DEFAULT_FORMAT = "[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"
+
+		# The format to output if debugging is turned on
+		DEFAULT_DEBUG_FORMAT = "[%1$s.%2$06d %3$d/%4$s] %5$5s {%6$s} -- %7$s\n"
+
+
+		### Initialize the formatter with a reference to the logger so it can check for log level.
+		def initialize( logger, format=DEFAULT_FORMAT, debug=DEFAULT_DEBUG_FORMAT ) # :notnew:
+			@logger       = logger
+			@format       = format
+			@debug_format = debug
+
+			super()
+		end
+
+		######
+		public
+		######
+
+		# The Logger object associated with the formatter
+		attr_accessor :logger
+
+		# The logging format string
+		attr_accessor :format
+
+		# The logging format string that's used when outputting in debug mode
+		attr_accessor :debug_format
+
+
+		### Log using either the DEBUG_FORMAT if the associated logger is at ::DEBUG level or
+		### using FORMAT if it's anything less verbose.
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity,                                                     # %5$s
+				progname,                                                     # %6$s
+				msg                                                           # %7$s
+			]
+
+			if @logger.level == Logger::DEBUG
+				return self.debug_format % args
+			else
+				return self.format % args
+			end
+		end
+	end # class LogFormatter
+
+
+	# An alternate formatter for Logger instances that outputs +dd+ HTML
+	# fragments.
+	class HtmlLogFormatter < Logger::Formatter # :nodoc:
+		include ERB::Util  # for html_escape()
+
+		# The default HTML fragment that'll be used as the template for each log message.
+		HTML_LOG_FORMAT = %q{
+		<div class="log-message %5$s">
+			<span class="log-time">%1$s.%2$06d</span>
+			[
+				<span class="log-pid">%3$d</span>
+				/
+				<span class="log-tid">%4$s</span>
+			]
+			<span class="log-level">%5$s</span>
+			:
+			<span class="log-name">%6$s</span>
+			<span class="log-message-text">%7$s</span>
+		</div>
+		}
+
+		### Override the logging formats with ones that generate HTML fragments
+		def initialize( logger, format=HTML_LOG_FORMAT ) # :notnew:
+			@logger = logger
+			@format = format
+			super()
+		end
+
+
+		######
+		public
+		######
+
+		# The HTML fragment that will be used as a format() string for the log
+		attr_accessor :format
+
+
+		### Return a log message composed out of the arguments formatted using the
+		### formatter's format string
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity.downcase,                                                     # %5$s
+				progname,                                                     # %6$s
+				html_escape( msg ).gsub(/\n/, '<br />')                       # %7$s
+			]
+
+			return self.format % args
+		end
+
+	end # class HtmlLogFormatter
+
+end # module OpenLDAP
+
+# vim: set nosta noet ts=4 sw=4:
+

data/spec/lib/constants.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+
+require 'openldap'
+
+
+module OpenLDAP::TestConstants
+
+	unless defined?( TEST_LDAP_URI )
+
+		TEST_CONFIG_FILE = Pathname( __FILE__ ).dirname.parent.parent + 'test.conf'
+
+		TEST_LOCAL_LDAP_STRING = 'ldap://localhost'
+		TEST_LOCAL_LDAP_URI = URI( TEST_LOCAL_LDAP_STRING )
+
+		TEST_LDAP_STRING = 'ldap://ldap.example.com'
+		TEST_LDAP_URI = URI( TEST_LDAP_STRING )
+
+		TEST_LDAPBASE_STRING = 'ldap://ldap.example.com/dc=example,dc=com'
+		TEST_LDAPBASE_URI = URI( TEST_LDAPBASE_STRING )
+
+		constants.each do |cname|
+			const_get(cname).freeze
+		end
+	end
+
+end
+

data/spec/lib/helpers.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/ruby
+# coding: utf-8
+
+BEGIN {
+	require 'rbconfig'
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent
+
+	libdir = basedir + "lib"
+	extdir = libdir + Config::CONFIG['sitearch']
+
+	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
+	$LOAD_PATH.unshift( extdir.to_s ) unless $LOAD_PATH.include?( extdir.to_s )
+}
+
+require 'pp'
+require 'yaml'
+require 'logger'
+
+require 'openldap'
+require 'openldap/mixins'
+
+require 'spec/lib/constants'
+
+### Return a string-comparable version vector from +version+.
+def vvec( version )
+	return version.split( '.' ).map( &:to_i ).pack( 'N' )
+end
+
+
+### RSpec helper functions.
+module OpenLDAP::SpecHelpers
+	include OpenLDAP::TestConstants
+
+	class ArrayLogger
+		### Create a new ArrayLogger that will append content to +array+.
+		def initialize( array )
+			@array = array
+		end
+
+		### Write the specified +message+ to the array.
+		def write( message )
+			@array << message
+		end
+
+		### No-op -- this is here just so Logger doesn't complain
+		def close; end
+
+	end # class ArrayLogger
+
+
+	unless defined?( LEVEL )
+		LEVEL = {
+			:debug => Logger::DEBUG,
+			:info  => Logger::INFO,
+			:warn  => Logger::WARN,
+			:error => Logger::ERROR,
+			:fatal => Logger::FATAL,
+		  }
+	end
+
+
+	###############
+	module_function
+	###############
+
+	### Reset the logging subsystem to its default state.
+	def reset_logging
+		OpenLDAP.reset_logger
+	end
+
+
+	### Alter the output of the default log formatter to be pretty in SpecMate output
+	def setup_logging( level=Logger::FATAL )
+
+		# Turn symbol-style level config into Logger's expected Fixnum level
+		if OpenLDAP::Loggable::LEVEL.key?( level )
+			level = OpenLDAP::Loggable::LEVEL[ level ]
+		end
+
+		logger = Logger.new( $stderr )
+		OpenLDAP.logger = logger
+		OpenLDAP.logger.level = level
+
+		# Only do this when executing from a spec in TextMate
+		if ENV['HTML_LOGGING'] || (ENV['TM_FILENAME'] && ENV['TM_FILENAME'] =~ /_spec\.rb/)
+			Thread.current['logger-output'] = []
+			logdevice = ArrayLogger.new( Thread.current['logger-output'] )
+			OpenLDAP.logger = Logger.new( logdevice )
+			# OpenLDAP.logger.level = level
+			OpenLDAP.logger.formatter = OpenLDAP::HtmlLogFormatter.new( OpenLDAP.logger )
+		end
+	end
+
+
+	### Load the testing LDAP config options from a YAML file.
+	def load_ldap_config
+		unless defined?( @ldap_config ) && @ldap_config
+			if TEST_CONFIG_FILE.exist?
+				$stderr.puts "Loading LDAP config from #{TEST_CONFIG_FILE}" if $VERBOSE
+				@ldap_config = YAML.load( TEST_CONFIG_FILE.read )
+			else
+				$stderr.puts "Skipping tests that require access to a live directory. Copy the ",
+					"#{TEST_CONFIG_FILE}-example file and provide valid values for testing",
+					"with an actual LDAP."
+				@ldap_config = {}
+			end
+		end
+
+		return @ldap_config
+	end
+
+end
+
+
+### Mock with Rspec
+RSpec.configure do |config|
+	include OpenLDAP::TestConstants
+
+	config.mock_with :rspec
+	config.include( OpenLDAP::SpecHelpers )
+
+	config.filter_run_excluding( :ruby_1_9_only => true ) if vvec( RUBY_VERSION ) >= vvec( '1.9.0' )
+	config.filter_run_excluding( :with_ldap_server => true ) unless TEST_CONFIG_FILE.exist?
+end
+
+# vim: set nosta noet ts=4 sw=4:
+

data/spec/openldap/connection_spec.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env rspec -cfd -b
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname( __FILE__ ).dirname.parent.parent
+	libdir = basedir + 'lib'
+
+	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
+	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
+}
+
+require 'uri'
+require 'rspec'
+require 'spec/lib/helpers'
+require 'openldap/connection'
+
+describe OpenLDAP::Connection do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it "can be created with an LDAP URI" do
+		conn = OpenLDAP::Connection.new( TEST_LDAP_URI )
+		conn.uris.should == [ TEST_LDAP_URI ]
+	end
+
+	it "can be created with an LDAP URI String" do
+		conn = OpenLDAP::Connection.new( TEST_LDAP_URI.to_s )
+		conn.uris.should == [ TEST_LDAP_URI ]
+	end
+
+	it "can be created with several LDAP URIs" do
+		conn = OpenLDAP::Connection.new( TEST_LDAP_URI, TEST_LOCAL_LDAP_URI )
+		conn.uris.should == [ TEST_LDAP_URI, TEST_LOCAL_LDAP_URI ]
+	end
+
+	context "an instance" do
+
+		before( :each ) do
+			@conn = OpenLDAP::Connection.new( TEST_LDAP_URI )
+		end
+
+		it "can set the cacert file used for TLS" do
+			@conn.tls_cacertfile = Pathname( '/etc/openssl/cacerts/ldap.pem' )
+			@conn.tls_cacertfile.should == '/etc/openssl/cacerts/ldap.pem'
+		end
+
+		it "can set the cacert directory used for TLS" do
+			@conn.tls_cacertdir = Pathname( '/etc/openssl/cacerts' )
+			@conn.tls_cacertdir.should == '/etc/openssl/cacerts'
+		end
+
+		it "can set the certificate file used for TLS" do
+			@conn.tls_certfile = Pathname( '/etc/openssl/host.pem' )
+			@conn.tls_certfile.should == '/etc/openssl/host.pem'
+		end
+
+
+		it "can set the cipher suite used for TLS" do
+			@conn.tls_cipher_suite = 'HIGH:MEDIUM:+SSLv2'
+			@conn.tls_cipher_suite.should == 'HIGH:MEDIUM:+SSLv2'
+		end
+
+		it "can set the CRL checking strategy used for TLS" do
+			@conn.tls_crlcheck = :all
+			@conn.tls_crlcheck.should == :all
+		end
+
+		it "can set the CRL file used for TLS" do
+			@conn.tls_crlfile = '/var/db/036D5FF52BA395A08BA2F780F9ADEAD905431757.crl'
+			@conn.tls_crlfile.should == '/var/db/036D5FF52BA395A08BA2F780F9ADEAD905431757.crl'
+		end
+
+		it "can set the dhfile used for TLS" do
+			@conn.tls_dhfile = '/etc/openssl/dh1024.pem'
+			@conn.tls_dhfile.should == '/etc/openssl/dh1024.pem'
+		end
+
+		it "can set the keyfile used for TLS" do
+			@conn.tls_keyfile = '/etc/openssl/host.key'
+			@conn.tls_keyfile.should == '/etc/openssl/host.key'
+		end
+
+		it "can set the package used for TLS in recent versions of libldap" do
+			if OpenLDAP.api_info[:vendor_name] == "OpenLDAP" &&
+				OpenLDAP.api_info[:vendor_version] >= 20426
+				@conn.tls_package.should == 'OpenSSL'
+			else
+				expect {
+					@conn.tls_package
+				}.to raise_error( NotImplementedError, /version of libldap/i )
+			end
+		end
+
+		it "can set the minimum protocol version used for TLS" do
+			@conn.tls_protocol_min = 11
+			@conn.tls_protocol_min.should == 11
+		end
+
+		it "can set the random_file used for TLS" do
+			# :TODO: Don't know how to test this appropriately.
+			# @conn.tls_random_file = '/dev/urandom'
+			@conn.tls_random_file.should be_nil()
+		end
+
+		it "can set the certificate verification strategy used for TLS" do
+			@conn.tls_require_cert = :demand
+			@conn.tls_require_cert.should == :demand
+		end
+
+		it "can be set to time out if the connect(2) takes longer than 2 seconds" do
+			@conn.network_timeout = 2.0
+			@conn.network_timeout.should == 2.0
+		end
+
+		it "can have its network timeout reset" do
+			@conn.network_timeout = nil
+			@conn.network_timeout.should be_nil()
+		end
+
+		it "can connect asynchronously" do
+			@conn.async_connect?.should be_false()
+			@conn.async_connect = true
+			@conn.async_connect?.should be_true()
+		end
+
+		it "can disable asynchronous connections after they've been enabled" do
+			@conn.async_connect = true
+			@conn.async_connect = false
+			@conn.async_connect?.should be_false()
+		end
+
+	end
+
+	context "an unconnected instance" do
+
+		before( :each ) do
+			@conn = OpenLDAP::Connection.new( TEST_LDAP_URI )
+		end
+
+		it "knows that its file-descriptor is nil" do
+			@conn.fdno.should be_nil()
+		end
+
+	end
+
+
+	it "can start TLS negotiation synchronously", :with_ldap_server => true do
+		config = load_ldap_config()
+		uri = config['uri'] or abort "No 'uri' in the test config!"
+
+		conn = OpenLDAP::Connection.new( uri )
+		conn.start_tls
+	end
+
+	context "a connected instance", :with_ldap_server => true do
+
+		before( :all ) do
+			config = load_ldap_config()
+			@uri = config['uri'] or abort "No 'uri' in the test config!"
+		end
+
+		before( :each ) do
+			@conn = OpenLDAP::Connection.new( @uri )
+			@conn.start_tls
+		end
+
+		it "knows what its file-descriptor is" do
+			@conn.fdno.should be_a( Fixnum )
+			@conn.fdno.should > 2 # Something past STDERR
+		end
+
+		it "can return an IO for selecting against its file-descriptor" do
+			@conn.socket.should be_an( IO )
+			@conn.socket.fileno.should == @conn.fdno
+			@conn.socket.should_not be_autoclose()
+			@conn.socket.should_not be_close_on_exec()
+			@conn.socket.should be_binmode()
+		end
+
+	end
+
+end
+