activeldap 3.1.1 → 3.2.0

data/lib/active_ldap/connection.rb

@@ -167,6 +167,7 @@ module ActiveLdap
 
       def reset_runtime
         active_connections.inject(0) do |result, (name, connection)|
+          _ = name # for suppress a warning on Ruby 1.9.3
           result + connection.reset_runtime
         end
       end
@@ -211,7 +212,7 @@ module ActiveLdap
             end
           end
           if !ruby_ldap_available and Object.const_defined?(:Gem)
-            ruby_ldap_available = Gem.available?("ruby-ldap")
+            ruby_ldap_available = gem_available?("ruby-ldap")
           end
           if ruby_ldap_available
             "ldap"
@@ -220,6 +221,10 @@ module ActiveLdap
           end
         end
       end
+
+      def gem_available?(name)
+        not Gem::Specification.find_all_by_name(name).empty?
+      end
     end
 
     def setup_connection(config=nil)

data/lib/active_ldap/get_text.rb

@@ -1,9 +1,20 @@
-if Object.const_defined?(:FastGettext)
-  ActiveLdap.const_set("GetText", FastGettext)
-end
+require "gettext"
 
-unless ActiveLdap.const_defined?(:GetText)
-  require 'active_ldap/get_text_fallback'
-end
+module ActiveLdap
+  class << self
+    def get_text_supported?
+      true
+    end
+  end
 
-require 'active_ldap/get_text_support'
+  module GetTextSupport
+    class << self
+      def included(base)
+        base.class_eval do
+          include(GetText)
+          bindtextdomain("active-ldap")
+        end
+      end
+    end
+  end
+end

data/lib/active_ldap/operations.rb

@@ -8,7 +8,9 @@ module ActiveLdap
           extend(Find)
           extend(LDIF)
           extend(Delete)
+          extend(ClassOnlyDelete)
           extend(Update)
+          extend(ClassOnlyUpdate)
 
           include(Common)
           include(Find)
@@ -22,7 +24,7 @@ module ActiveLdap
     module Common
       VALID_SEARCH_OPTIONS = [:attribute, :value, :filter, :prefix,
                               :classes, :scope, :limit, :attributes,
-                              :sort_by, :order, :connection, :base]
+                              :sort_by, :order, :connection, :base, :offset]
 
       def search(options={}, &block)
         validate_search_options(options)
@@ -31,6 +33,7 @@ module ActiveLdap
         filter = options[:filter]
         prefix = options[:prefix]
         classes = options[:classes]
+        requested_attributes = options[:attributes]
 
         value = value.first if value.is_a?(Array) and value.first.size == 1
 
@@ -56,20 +59,25 @@ module ActiveLdap
           :scope => options[:scope] || scope,
           :filter => filter,
           :limit => options[:limit],
-          :attributes => options[:attributes],
+          :attributes => requested_attributes,
           :sort_by => options[:sort_by] || sort_by,
           :order => options[:order] || order,
         }
-
         options[:connection] ||= connection
         values = []
+        requested_all_attributes_p =
+          (requested_attributes.nil? or requested_attributes.include?('*'))
         options[:connection].search(search_options) do |dn, attrs|
           attributes = {}
           attrs.each do |key, _value|
-            normalized_attr, normalized_value =
-              normalize_attribute_options(key, _value)
-            attributes[normalized_attr] ||= []
-            attributes[normalized_attr].concat(normalized_value)
+            if requested_all_attributes_p or requested_attributes.include?(key)
+              normalized_attribute, normalized_value =
+                normalize_attribute_options(key, _value)
+              attributes[normalized_attribute] ||= []
+              attributes[normalized_attribute].concat(normalized_value)
+            else
+              next
+            end
           end
           values << [dn, attributes]
         end
@@ -280,8 +288,9 @@ module ActiveLdap
         sort_by = options.delete(:sort_by) || self.sort_by
         order = options.delete(:order) || self.order
         limit = options.delete(:limit) if sort_by or order
-        options[:attributes] |= ["objectClass"] if options[:attributes]
-
+        offset = options.delete(:offset) || offset
+        options[:attributes] = options.delete(:attributes) || ['*']
+        options[:attributes] |= ['objectClass']
         results = search(options).collect do |dn, attrs|
           instantiate([dn, attrs, {:connection => options[:connection]}])
         end
@@ -295,6 +304,7 @@ module ActiveLdap
         end
 
         results.reverse! if normalize_sort_order(order || "ascend") == :descend
+        results = results[offset, results.size] if offset
         results = results[0, limit] if limit
         results
       end
@@ -479,13 +489,6 @@ module ActiveLdap
     end
 
     module Delete
-      def destroy(targets, options={})
-        targets = [targets] unless targets.is_a?(Array)
-        targets.each do |target|
-          find(target, options).destroy
-        end
-      end
-
       def destroy_all(options_or_filter=nil, deprecated_options=nil)
         if deprecated_options.nil?
           if options_or_filter.is_a?(String)
@@ -504,24 +507,6 @@ module ActiveLdap
         end
       end
 
-      def delete(targets, options={})
-        targets = [targets] unless targets.is_a?(Array)
-        targets = targets.collect do |target|
-          ensure_dn_attribute(ensure_base(target))
-        end
-        delete_entry(targets, options)
-      end
-
-      def delete_entry(dn, options={})
-        options[:connection] ||= connection
-        begin
-          options[:connection].delete(dn, options)
-        rescue Error
-          format = _("Failed to delete LDAP entry: <%s>: %s")
-          raise DeleteError.new(format % [dn.inspect, $!.message])
-        end
-      end
-
       def delete_all(options_or_filter=nil, deprecated_options=nil)
         if deprecated_options.nil?
           if options_or_filter.is_a?(String)
@@ -540,6 +525,33 @@ module ActiveLdap
 
         delete_entry(targets, options)
       end
+
+      def delete_entry(dn, options={})
+        options[:connection] ||= connection
+        begin
+          options[:connection].delete(dn, options)
+        rescue Error
+          format = _("Failed to delete LDAP entry: <%s>: %s")
+          raise DeleteError.new(format % [dn.inspect, $!.message])
+        end
+      end
+    end
+
+    module ClassOnlyDelete
+      def destroy(targets, options={})
+        targets = [targets] unless targets.is_a?(Array)
+        targets.each do |target|
+          find(target, options).destroy
+        end
+      end
+
+      def delete(targets, options={})
+        targets = [targets] unless targets.is_a?(Array)
+        targets = targets.collect do |target|
+          ensure_dn_attribute(ensure_base(target))
+        end
+        delete_entry(targets, options)
+      end
     end
 
     module Update
@@ -566,21 +578,6 @@ module ActiveLdap
                                         new_superior, options)
       end
 
-      def update(dn, attributes, options={})
-        if dn.is_a?(Array)
-          i = -1
-          dns = dn
-          dns.collect do |_dn|
-            i += 1
-            update(_dn, attributes[i], options)
-          end
-        else
-          object = find(dn, options)
-          object.update_attributes(attributes)
-          object
-        end
-      end
-
       def update_all(attributes, filter=nil, options={})
         search_options = options.dup
         if filter
@@ -606,5 +603,22 @@ module ActiveLdap
         end
       end
     end
+
+    module ClassOnlyUpdate
+      def update(dn, attributes, options={})
+        if dn.is_a?(Array)
+          i = -1
+          dns = dn
+          dns.collect do |_dn|
+            i += 1
+            update(_dn, attributes[i], options)
+          end
+        else
+          object = find(dn, options)
+          object.update_attributes(attributes)
+          object
+        end
+      end
+    end
   end
 end

data/lib/active_ldap/persistence.rb

@@ -72,5 +72,22 @@ module ActiveLdap
         true
       end
     end
+
+    def reload
+      clear_association_cache
+      _, attributes = search(:value => id).find do |_dn, _attributes|
+        dn == _dn
+      end
+      if attributes.nil?
+        raise EntryNotFound, _("Can't find DN '%s' to reload") % dn
+      end
+
+      @ldap_data.update(attributes)
+      classes, attributes = extract_object_class(attributes)
+      self.classes = classes
+      self.attributes = attributes
+      @new_entry = false
+      self
+    end
   end # Persistence
 end # ActiveLdap

data/lib/active_ldap/railtie.rb

@@ -1,6 +1,9 @@
+require "locale"
 require 'active_ldap'
 require 'rails'
 
+Locale.init(:driver => :cgi)
+
 module ActiveLdap
   class Railtie < Rails::Railtie
     config.app_generators.orm :active_ldap

data/lib/active_ldap/schema.rb

@@ -12,6 +12,7 @@ module ActiveLdap
     def ids(group)
       ensure_parse(group)
       info, ids, aliases = ensure_schema_info(group)
+      _ = info = aliases # for suppress a warning on Ruby 1.9.3
       ids.keys
     end
 
@@ -54,6 +55,7 @@ module ActiveLdap
 
       # Initialize anything that is required
       info, ids, aliases = ensure_schema_info(group)
+      _ = info # for suppress a warning on Ruby 1.9.3
       id, name = determine_id_or_name(id_or_name, aliases)
 
       # Check already parsed options first

data/lib/active_ldap/schema/syntaxes.rb

@@ -180,10 +180,10 @@ module ActiveLdap
           return value if value.nil? or value.is_a?(Time)
           match_data = FORMAT.match(value)
           if match_data
-            required_components = match_data.to_a[1, 6]
+            required_components = match_data.to_a[1, 5]
             return value if required_components.any?(&:nil?)
-            year, month, day, hour, minute, second =
-              required_components.collect(&:to_i)
+            year, month, day, hour, minute = required_components.collect(&:to_i)
+            second = match_data[-3].to_i
             fraction = match_data[-2]
             fraction = fraction.to_f if fraction
             time_zone = match_data[-1]
@@ -224,11 +224,11 @@ module ActiveLdap
         def validate_normalized_value(value, original_value)
           match_data = FORMAT.match(value)
           if match_data
-            year, month, day, hour, minute, second, fraction, time_zone =
-              match_data.to_a[1..-1]
+            date_data = match_data.to_a[1..-1]
             missing_components = []
-            %w(year month day hour minute second).each do |component|
-              missing_components << component unless eval(component)
+            required_components = %w(year month day hour minute)
+            required_components.each_with_index do |component, i|
+              missing_components << component unless date_data[i]
             end
             if missing_components.empty?
               nil

data/lib/active_ldap/validations.rb

@@ -41,11 +41,11 @@ module ActiveLdap
     end
 
     def save(*)
-      valid? ? super: false
+      valid? ? super : false
     end
 
     def save!(*)
-      valid? ? super: raise(EntryInvalid.new(self))
+      valid? ? super : raise(EntryInvalid.new(self))
     end
 
     private

data/lib/active_ldap/version.rb

@@ -0,0 +1,3 @@
+module ActiveLdap
+  VERSION = "3.2.0"
+end

data/lib/active_ldap/xml.rb

@@ -6,7 +6,7 @@ require 'active_ldap/ldif'
 module ActiveLdap
   class Xml
     class Serializer
-      PRINTABLE_STRING = /[\x20-\x7e\w\s]*/
+      PRINTABLE_STRING = /[\x20-\x7e\t\r\n]*/n
 
       def initialize(dn, attributes, schema, options={})
         @dn = dn
@@ -23,6 +23,7 @@ module ActiveLdap
           target_attributes.each do |key, values|
             values = normalize_values(values).sort_by {|value, _| value}
             if @schema.attribute(key).single_value?
+              next if values.empty?
               serialize_attribute_value(xml, key, *values[0])
             else
               serialize_attribute_values(xml, key, values)
@@ -34,13 +35,29 @@ module ActiveLdap
       private
       def target_attributes
         except_dn = false
-        attributes = @attributes.dup
-        (@options[:except] || []).each do |name|
-          if name == "dn"
-            except_dn = true
-          else
-            attributes.delete(name)
+        only = @options[:only] || []
+        except = @options[:except] || []
+        if !only.empty?
+          attributes = []
+          except_dn = true
+          only.each do |name|
+            if name == "dn"
+              except_dn = false
+            elsif @attributes.has_key?(name)
+              attributes << [name, @attributes[name]]
+            end
           end
+        elsif !except.empty?
+          attributes = @attributes.dup
+          except.each do |name|
+            if name == "dn"
+              except_dn = true
+            else
+              attributes.delete(name)
+            end
+          end
+        else
+          attributes = @attributes.dup
         end
         attributes = attributes.sort_by {|key, values| key}
         attributes.unshift(["dn", [@dn]]) unless except_dn

data/lib/rails/generators/active_ldap/model/model_generator.rb

@@ -33,10 +33,10 @@ module ActiveLdap
       
       def ldap_mapping(indent='  ')
         mapping = "ldap_mapping "
-        mapping_options = [":dn_attribute => #{options[:dn_attribute].dump}"]
-        mapping_options << ":prefix => #{prefix.dump}"
+        mapping_options = [key_value(:dn_attribute, options[:dn_attribute].dump)]
+        mapping_options << key_value(:prefix, prefix.dump)
         if options[:classes]
-          mapping_options << ":classes => #{options[:classes].inspect}"
+          mapping_options << key_value(:classes, options[:classes].inspect)
         end
         mapping_options = mapping_options.join(",\n#{indent}#{' ' * mapping.size}")
         "#{indent}#{mapping}#{mapping_options}"

data/test/add-phonetic-attribute-options-to-slapd.ldif

@@ -0,0 +1,10 @@
+# Your LDAP server need to accept 'phonetic' attribute option for test.
+# This is a LDIF file for OpenLDAP to do the confiugration.
+# You can use this file by the following command linne on Debian GNU/Linux
+# or Ubuntu:
+#   % sudo -H ldapmodify -Y EXTERNAL -H ldapi:/// -f test/add-phonetic-attribute-options-to-slapd.ldif
+version: 1
+dn: cn=config
+changetype: modify
+add: olcAttributeOptions
+olcAttributeOptions: phonetic lang-

data/test/al-test-utils.rb

@@ -0,0 +1,428 @@
+require 'test-unit'
+
+require 'erb'
+require 'yaml'
+require 'socket'
+require 'rbconfig'
+require 'tempfile'
+
+require 'active_ldap'
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "command")
+
+LDAP_ENV = "test" unless defined?(LDAP_ENV)
+
+module AlTestUtils
+  def self.included(base)
+    base.class_eval do
+      include ActiveLdap::GetTextSupport
+      include Utilities
+      include Config
+      include Connection
+      include Populate
+      include TemporaryEntry
+      include CommandSupport
+      include MockLogger
+    end
+  end
+
+  module Utilities
+    def dn(string)
+      ActiveLdap::DN.parse(string)
+    end
+  end
+
+  module Config
+    def setup
+      super
+      @base_dir = File.expand_path(File.dirname(__FILE__))
+      @top_dir = File.expand_path(File.join(@base_dir, ".."))
+      @example_dir = File.join(@top_dir, "examples")
+      @fixtures_dir = File.join(@base_dir, "fixtures")
+      @config_file = File.join(@base_dir, "config.yaml")
+      ActiveLdap::Base.configurations = read_config
+    end
+
+    def teardown
+      super
+    end
+
+    def current_configuration
+      ActiveLdap::Base.configurations[LDAP_ENV]
+    end
+
+    def read_config
+      unless File.exist?(@config_file)
+        raise "config file for testing doesn't exist: #{@config_file}"
+      end
+      erb = ERB.new(File.read(@config_file))
+      erb.filename = @config_file
+      config = YAML.load(erb.result)
+      _adapter = adapter
+      config.each do |key, value|
+        value["adapter"] = _adapter if _adapter
+      end
+      config
+    end
+
+    def adapter
+      ENV["ACTIVE_LDAP_TEST_ADAPTER"]
+    end
+
+    def fixture(*components)
+      File.join(@fixtures_dir, *components)
+    end
+  end
+
+  module ExampleFile
+    def certificate_path
+      File.join(@example_dir, 'example.der')
+    end
+
+    @@certificate = nil
+    def certificate
+      return @@certificate if @@certificate
+      if File.exists?(certificate_path)
+        @@certificate = read_binary_file(certificate_path)
+        return @@certificate
+      end
+
+      require 'openssl'
+      rsa = OpenSSL::PKey::RSA.new(512)
+      comment = "Generated by Ruby/OpenSSL"
+
+      cert = OpenSSL::X509::Certificate.new
+      cert.version = 3
+      cert.serial = 0
+      subject = [["OU", "test"],
+                 ["CN", Socket.gethostname]]
+      name = OpenSSL::X509::Name.new(subject)
+      cert.subject = name
+      cert.issuer = name
+      cert.not_before = Time.now
+      cert.not_after = Time.now + (365*24*60*60)
+      cert.public_key = rsa.public_key
+
+      ef = OpenSSL::X509::ExtensionFactory.new(nil, cert)
+      ef.issuer_certificate = cert
+      cert.extensions = [
+        ef.create_extension("basicConstraints","CA:FALSE"),
+        ef.create_extension("keyUsage", "keyEncipherment"),
+        ef.create_extension("subjectKeyIdentifier", "hash"),
+        ef.create_extension("extendedKeyUsage", "serverAuth"),
+        ef.create_extension("nsComment", comment),
+      ]
+      aki = ef.create_extension("authorityKeyIdentifier",
+                                "keyid:always,issuer:always")
+      cert.add_extension(aki)
+      cert.sign(rsa, OpenSSL::Digest::SHA1.new)
+
+      @@certificate = cert.to_der
+      @@certificate
+    end
+
+    def jpeg_photo_path
+      File.join(@example_dir, 'example.jpg')
+    end
+
+    def jpeg_photo
+      read_binary_file(jpeg_photo_path)
+    end
+
+    def read_binary_file(path)
+      File.open(path, "rb") do |input|
+        input.set_encoding("ascii-8bit") if input.respond_to?(:set_encoding)
+        input.read
+      end
+    end
+  end
+
+  module Connection
+    def setup
+      super
+      ActiveLdap::Base.setup_connection
+    end
+
+    def teardown
+      ActiveLdap::Base.remove_active_connections!
+      super
+    end
+  end
+
+  module Populate
+    def setup
+      @dumped_data = nil
+      super
+      begin
+        @dumped_data = ActiveLdap::Base.dump(:scope => :sub)
+      rescue ActiveLdap::ConnectionError
+      end
+      ActiveLdap::Base.delete_all(nil, :scope => :sub)
+      populate
+    end
+
+    def teardown
+      if @dumped_data
+        ActiveLdap::Base.setup_connection
+        ActiveLdap::Base.delete_all(nil, :scope => :sub)
+        ActiveLdap::Base.load(@dumped_data)
+      end
+      super
+    end
+
+    def populate
+      populate_base
+      populate_ou
+      populate_user_class
+      populate_group_class
+      populate_associations
+    end
+
+    def populate_base
+      ActiveLdap::Populate.ensure_base
+    end
+
+    def ou_class(prefix="")
+      ou_class = Class.new(ActiveLdap::Base)
+      ou_class.ldap_mapping(:dn_attribute => "ou",
+                            :prefix => prefix,
+                            :classes => ["top", "organizationalUnit"])
+      ou_class
+    end
+
+    def dc_class(prefix="")
+      dc_class = Class.new(ActiveLdap::Base)
+      dc_class.ldap_mapping(:dn_attribute => "dc",
+                            :prefix => prefix,
+                            :classes => ["top", "dcObject", "organization"])
+      dc_class
+    end
+
+    def entry_class(prefix="")
+      entry_class = Class.new(ActiveLdap::Base)
+      entry_class.ldap_mapping(:prefix => prefix,
+                               :scope => :sub,
+                               :classes => ["top"])
+      entry_class.dn_attribute = nil
+      entry_class
+    end
+
+    def populate_ou
+      %w(Users Groups).each do |name|
+        make_ou(name)
+      end
+    end
+
+    def make_ou(name)
+      ActiveLdap::Populate.ensure_ou(name)
+    end
+
+    def make_dc(name)
+      ActiveLdap::Populate.ensure_dc(name)
+    end
+
+    def populate_user_class
+      @user_class = Class.new(ActiveLdap::Base)
+      @user_class_classes = ["posixAccount", "person"]
+      @user_class.ldap_mapping :dn_attribute => "uid",
+                               :prefix => "ou=Users",
+                               :scope => :sub,
+                               :classes => @user_class_classes
+      assign_class_name(@user_class, "User")
+    end
+
+    def populate_group_class
+      @group_class = Class.new(ActiveLdap::Base)
+      @group_class.ldap_mapping :prefix => "ou=Groups",
+                                :scope => :sub,
+                                :classes => ["posixGroup"]
+      assign_class_name(@group_class, "Group")
+    end
+
+    def populate_associations
+      @user_class.belongs_to :groups, :many => "memberUid"
+      @user_class.belongs_to :primary_group,
+                             :foreign_key => "gidNumber",
+                             :primary_key => "gidNumber"
+      @group_class.has_many :members, :wrap => "memberUid"
+      @group_class.has_many :primary_members,
+                            :foreign_key => "gidNumber",
+                            :primary_key => "gidNumber"
+      @user_class.set_associated_class(:groups, @group_class)
+      @user_class.set_associated_class(:primary_group, @group_class)
+      @group_class.set_associated_class(:members, @user_class)
+      @group_class.set_associated_class(:primary_members, @user_class)
+    end
+
+    def assign_class_name(klass, name)
+      singleton_class = class << klass; self; end
+      singleton_class.send(:define_method, :name) do
+        name
+      end
+      if Object.const_defined?(klass.name)
+        Object.send(:remove_const, klass.name)
+      end
+      Object.const_set(klass.name, klass)
+    end
+  end
+
+  module TemporaryEntry
+    include ExampleFile
+
+    def setup
+      super
+      @user_index = 0
+      @group_index = 0
+    end
+
+    def make_temporary_user(config={})
+      @user_index += 1
+      uid = config[:uid] || "temp-user#{@user_index}"
+      ensure_delete_user(uid) do
+        password = config[:password] || "password#{@user_index}"
+        uid_number = config[:uid_number] || default_uid
+        gid_number = config[:gid_number] || default_gid
+        home_directory = config[:home_directory] || "/nonexistent"
+        see_also = config[:see_also]
+        _wrap_assertion do
+          assert(!@user_class.exists?(uid))
+          assert_raise(ActiveLdap::EntryNotFound) do
+            @user_class.find(uid).dn
+          end
+          user = @user_class.new(uid)
+          assert(user.new_entry?)
+          user.cn = user.uid
+          user.sn = user.uid
+          user.uid_number = uid_number
+          user.gid_number = gid_number
+          user.home_directory = home_directory
+          user.user_password = ActiveLdap::UserPassword.ssha(password)
+          user.see_also = see_also
+          unless config[:simple]
+            user.add_class('shadowAccount', 'inetOrgPerson',
+                           'organizationalPerson')
+            user.user_certificate = certificate
+            user.jpeg_photo = jpeg_photo
+          end
+          user.save
+          assert(!user.new_entry?)
+          yield(@user_class.find(user.uid), password)
+        end
+      end
+    end
+
+    def make_temporary_group(config={})
+      @group_index += 1
+      cn = config[:cn] || "temp-group#{@group_index}"
+      ensure_delete_group(cn) do
+        gid_number = config[:gid_number] || default_gid
+        _wrap_assertion do
+          assert(!@group_class.exists?(cn))
+          assert_raise(ActiveLdap::EntryNotFound) do
+            @group_class.find(cn)
+          end
+          group = @group_class.new(cn)
+          assert(group.new_entry?)
+          group.gid_number = gid_number
+          assert(group.save)
+          assert(!group.new_entry?)
+          yield(@group_class.find(group.cn))
+        end
+      end
+    end
+
+    def ensure_delete_user(uid)
+      yield(uid)
+    ensure
+      if @user_class.exists?(uid)
+        @user_class.search(:value => uid) do |dn, attribute|
+          @user_class.remove_connection(dn)
+          @user_class.delete(dn)
+        end
+      end
+    end
+
+    def ensure_delete_group(cn)
+      yield(cn)
+    ensure
+      @group_class.delete(cn) if @group_class.exists?(cn)
+    end
+
+    def default_uid
+      "10000#{@user_index}"
+    end
+
+    def default_gid
+      "10000#{@group_index}"
+    end
+  end
+
+  module CommandSupport
+    def setup
+      super
+      @fakeroot = "fakeroot"
+      @ruby = File.join(::RbConfig::CONFIG["bindir"],
+                        ::RbConfig::CONFIG["RUBY_INSTALL_NAME"])
+      @top_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+      @examples_dir = File.join(@top_dir, "examples")
+      @lib_dir = File.join(@top_dir, "lib")
+      @ruby_args = [
+                    "-I", @examples_dir,
+                    "-I", @lib_dir,
+                   ]
+    end
+
+    def run_command(*args, &block)
+      file = Tempfile.new("al-command-support")
+      file.open
+      file.puts(ActiveLdap::Base.configurations["test"].to_yaml)
+      file.close
+      run_ruby(*[@command, "--config", file.path, *args], &block)
+    end
+
+    def run_ruby(*ruby_args, &block)
+      args = [@ruby, *@ruby_args]
+      args.concat(ruby_args)
+      Command.run(*args, &block)
+    end
+
+    def run_ruby_with_fakeroot(*ruby_args, &block)
+      args = [@fakeroot, @ruby, *@ruby_args]
+      args.concat(ruby_args)
+      Command.run(*args, &block)
+    end
+  end
+
+  module MockLogger
+    def make_mock_logger
+      logger = Object.new
+      class << logger
+        def messages(type)
+          @messages ||= {}
+          @messages[type] ||= []
+          @messages[type]
+        end
+
+        def info(content=nil)
+          messages(:info) << (block_given? ? yield : content)
+        end
+        def warn(content=nil)
+          messages(:warn) << (block_given? ? yield : content)
+        end
+        def error(content=nil)
+          messages(:error) << (block_given? ? yield : content)
+        end
+      end
+      logger
+    end
+
+    def with_mock_logger
+      original_logger = ActiveLdap::Base.logger
+      mock_logger = make_mock_logger
+      ActiveLdap::Base.logger = mock_logger
+      yield(mock_logger)
+    ensure
+      ActiveLdap::Base.logger = original_logger
+    end
+  end
+end