ruby-activeldap 0.7.4 → 0.8.0

data/test/test_usermod-binary-del.rb

@@ -0,0 +1,64 @@
+require 'al-test-utils'
+
+class TestUsermodBinaryDel < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "usermod-binary-del")
+    make_ou("People")
+    @user_class.instance_variable_set("@prefix", "ou=People")
+  end
+
+  priority :must
+
+  priority :normal
+  def test_non_exist_user
+    ensure_delete_user("test-user") do |uid,|
+      assert(!@user_class.exists?(uid))
+      assert_equal([false, "User #{uid} doesn't exist.\n"],
+                   run_command(uid, "New CN", 11111))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_modify_user
+    make_temporary_user(:simple => true) do |user, password|
+      user.add_class("strongAuthenticationUser")
+      user.user_certificate = certificate
+      assert(user.save)
+      assert_usermod_binary_del_successfully(user.uid, "New #{user.cn}",
+                                             user.uid_number.to_i + 100)
+    end
+  end
+
+  private
+  def assert_usermod_binary_del_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      previous_classes = @user_class.find(name).classes
+      assert_operator(previous_classes, :include?, "strongAuthenticationUser")
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal(cn, user.cn)
+      assert_equal(uid.to_s, user.uid_number)
+      assert_equal(uid.to_s, user.gid_number)
+      assert_equal((previous_classes - ['strongAuthenticationUser']).sort,
+                   user.classes.sort)
+      assert(!user.respond_to?(:user_certificate))
+    end
+  end
+
+  def assert_usermod_binary_del_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_usermod-lang-add.rb

@@ -0,0 +1,57 @@
+require 'al-test-utils'
+
+class TestUsermodLangAdd < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "usermod-lang-add")
+    make_ou("People")
+    @user_class.instance_variable_set("@prefix", "ou=People")
+  end
+
+  priority :must
+
+  priority :normal
+  def test_non_exist_user
+    ensure_delete_user("test-user") do |uid,|
+      assert(!@user_class.exists?(uid))
+      assert_equal([false, "User #{uid} doesn't exist.\n"],
+                   run_command(uid, "New CN", 11111))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_modify_user
+    make_temporary_user do |user, password|
+      assert_usermod_lang_add_successfully(user.uid, "New #{user.cn}",
+                                           user.uid_number.to_i + 100)
+    end
+  end
+
+  private
+  def assert_usermod_lang_add_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      previous_classes = @user_class.find(name).classes
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal([cn, {'lang-en-us' => cn}], user.cn)
+      assert_equal(uid.to_s, user.uid_number)
+      assert_equal(uid.to_s, user.gid_number)
+    end
+  end
+
+  def assert_usermod_lang_add_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_usermod.rb

@@ -0,0 +1,56 @@
+require 'al-test-utils'
+
+class TestUsermod < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "usermod")
+    make_ou("People")
+    @user_class.instance_variable_set("@prefix", "ou=People")
+  end
+
+  priority :must
+
+  priority :normal
+  def test_non_exist_user
+    ensure_delete_user("test-user") do |uid,|
+      assert(!@user_class.exists?(uid))
+      assert_equal([false, "User #{uid} doesn't exist.\n"],
+                   run_command(uid, "New CN", 11111))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_modify_user
+    make_temporary_user do |user, password|
+      assert_usermod_successfully(user.uid, "New #{user.cn}",
+                                  user.uid_number.to_i + 100)
+    end
+  end
+
+  private
+  def assert_usermod_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal(cn, user.cn)
+      assert_equal(uid.to_s, user.uid_number)
+      assert_equal(uid.to_s, user.gid_number)
+    end
+  end
+
+  def assert_usermod_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_validation.rb

@@ -0,0 +1,38 @@
+require 'al-test-utils'
+
+class TestValidation < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+
+  priority :normal
+  def test_save!
+    make_temporary_group do |group|
+      group.description = ""
+
+      assert_nothing_raised do
+        group.save!
+      end
+
+      @group_class.validates_presence_of(:description)
+      assert_raises(ActiveLdap::EntryInvalid) do
+        group.save!
+      end
+    end
+  end
+
+  def test_validates_presence_of
+    make_temporary_group do |group|
+      assert_nothing_raised do
+        group.description = ""
+      end
+      assert(group.valid?)
+      assert_equal([], group.errors.to_a)
+
+      @group_class.validates_presence_of(:description)
+      assert(!group.valid?)
+      assert(group.errors.invalid?(:description))
+      assert_equal(1, group.errors.size)
+    end
+  end
+end

metadata

@@ -1,21 +1,23 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.0
 specification_version: 1
 name: ruby-activeldap
 version: !ruby/object:Gem::Version 
-  version: 0.7.4
-date: 2006-06-05 00:00:00 +01:00
-summary: Ruby/ActiveLDAP is a object-oriented API to LDAP
+  version: 0.8.0
+date: 2006-11-20 00:00:00 +00:00
+summary: Ruby/ActiveLdap is a object-oriented API to LDAP
 require_paths: 
 - lib
-email: will@alum.bu.edu
-homepage: http://projects.dataspill.org/libraries/ruby/activeldap/index.html
+email: 
+- will@alum.bu.edu
+- kou@cozmixng.org
+homepage: http://rubyforge.org/projects/ruby-activeldap/
 rubyforge_project: ruby-activeldap
-description: 
-autorequire: activeldap
+description: "'Ruby/ActiveLdap' is a ruby extension library which provides a clean objected oriented interface to the Ruby/LDAP library.  It was inspired by ActiveRecord. This is not nearly as clean or as flexible as ActiveRecord, but it is still trivial to define new objects and manipulate them with minimal difficulty."
+autorequire: active_ldap
 default_executable: 
 bindir: bin
-has_rdoc: false
+has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
   - - ">"
@@ -25,20 +27,82 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Will Drewry
+- Kouhei Sutou
 files: 
-- lib/activeldap
-- lib/activeldap.rb
-- lib/activeldap/associations.rb
-- lib/activeldap/base.rb
-- lib/activeldap/configuration.rb
-- lib/activeldap/ldap.rb
-- lib/activeldap/schema2.rb
-- lib/activeldap/timeout.rb
-- lib/activeldap/timeout_stub.rb
-test_files: []
-
+- Rakefile
+- LICENSE
+- TODO
+- COPYING
+- CHANGES
+- README
+- Manifest.txt
+- lib/active_ldap/adaptor/ldap.rb
+- lib/active_ldap/adaptor/base.rb
+- lib/active_ldap/association/has_many_wrap.rb
+- lib/active_ldap/association/has_many.rb
+- lib/active_ldap/association/proxy.rb
+- lib/active_ldap/association/belongs_to_many.rb
+- lib/active_ldap/association/collection.rb
+- lib/active_ldap/association/belongs_to.rb
+- lib/active_ldap/validations.rb
+- lib/active_ldap/command.rb
+- lib/active_ldap/callbacks.rb
+- lib/active_ldap/ldap.rb
+- lib/active_ldap/timeout_stub.rb
+- lib/active_ldap/timeout.rb
+- lib/active_ldap/attributes.rb
+- lib/active_ldap/object_class.rb
+- lib/active_ldap/connection.rb
+- lib/active_ldap/associations.rb
+- lib/active_ldap/user_password.rb
+- lib/active_ldap/schema.rb
+- lib/active_ldap/configuration.rb
+- lib/active_ldap/base.rb
+- lib/active_ldap.rb
+- benchmark/bench-al.rb
+- rails/plugin/active_ldap/init.rb
+- rails/plugin/active_ldap/README
+test_files: 
+- test/test-unit-ext
+- test/test_useradd.rb
+- test/test_user.rb
+- test/command.rb
+- test/test_usermod.rb
+- test/test_bind.rb
+- test/test_usermod-binary-add-time.rb
+- test/test_usermod-lang-add.rb
+- test/test_attributes.rb
+- test/test_usermod-binary-add.rb
+- test/test_validation.rb
+- test/test-unit-ext.rb
+- test/test_object_class.rb
+- test/test_groupmod.rb
+- test/test_associations.rb
+- test/test_user_password.rb
+- test/test_base_per_instance.rb
+- test/al-test-utils.rb
+- test/test_useradd-binary.rb
+- test/test_groupdel.rb
+- test/test_find.rb
+- test/test_groupls.rb
+- test/run-test.rb
+- test/TODO
+- test/config.yaml.sample
+- test/test_reflection.rb
+- test/test_connection_per_class.rb
+- test/test_callback.rb
+- test/test_connection.rb
+- test/test_schema.rb
+- test/test_userdel.rb
+- test/test_usermod-binary-del.rb
+- test/test_groupadd.rb
+- test/test_base.rb
+- test/test_userls.rb
+- test/test_lpasswd.rb
+- test/config.yaml
 rdoc_options: []
 
 extra_rdoc_files: []
@@ -48,8 +112,8 @@ executables: []
 extensions: []
 
 requirements: 
+- ruby-ldap >= 0.8.2
 - (Open)LDAP server
-- ruby-ldap = 0.8.2
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: log4r
@@ -60,3 +124,12 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.0.4
     version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 

data/lib/activeldap/associations.rb

@@ -1,170 +0,0 @@
-
-module ActiveLDAP
- # Associations
- #
- # Associations provides the class methods needed for
- # the extension classes to create methods using
- # belongs_to and has_many
- module Associations
-   def self.append_features(base)
-     super
-     base.extend(ClassMethods)
-   end
-   module ClassMethods
-
-     # This class function is used to setup all mappings between the subclass
-     # and ldap for use in activeldap
-     #
-     # Example:
-     #   ldap_mapping :dnattr => 'uid', :prefix => 'ou=People', 
-     #                :classes => ['top', 'posixAccount'], scope => LDAP::LDAP_SCOPE_SUBTREE,
-     #                :parent => String
-     def ldap_mapping(options = {})
-       # The immediate ancestor should be the caller....
-       klass = self.ancestors[0]
-
-       dnattr = options[:dnattr] || 'cn'
-       prefix = options[:prefix] || "ou=#{klass.to_s.split(':').last}"
-       classes_array = options[:classes] || nil
-       scope = options[:scope] || 'super'
-       # When used, instantiates parent objects from the "parent dn". This
-       # can be a String or a real ActiveLDAP class. This just adds the helper 
-       # Base#parent.
-       parent = options[:parent_class] || nil
-
-       classes = 'super'
-       unless classes_array.nil?
-         raise TypeError, ":classes must be an array" \
-           unless classes_array.respond_to? :size
-         # Build classes array
-         classes = '['
-         classes_array.map! {|x| x = "'#{x}'"}
-         classes << classes_array.join(', ')
-         classes << ']'
-       end
-
-       # This adds the methods to the local
-       # class which can then be inherited, etc
-       # which describe the mapping to LDAP.
-       klass.class_eval(<<-"end_eval")
-         class << self
-           # Return the list of required object classes
-           def required_classes
-             #{classes}
-           end
-
-           # Return the full base of the class
-           def base
-             if "#{prefix}".empty?
-               return "\#{super}"
-             else
-               return "#{prefix},\#{super}"
-             end
-           end
-
-           # Return the expected DN attribute of an object
-           def dnattr
-             '#{dnattr}'
-           end
-
-           # Return the expected DN attribute of an object
-           def ldap_scope
-             #{scope}
-           end
-         end
-         
-         # Hide connect
-         private_class_method :connect
-
-         # Unhide class methods
-         public_class_method :find_all
-         public_class_method :find
-         public_class_method :new
-         public_class_method :dnattr
-      end_eval
-
-      # Add the parent helper if desired
-      if parent
-        klass.class_eval(<<-"end_eval")
-          def parent()
-            return #{parent}.new(@dn.split(',')[1..-1].join(','))
-          end
-        end_eval
-      end
-     end
-
-    # belongs_to
-    #
-    # This defines a method for an extension class map its DN key
-    # attribute value on to multiple items which reference it by
-    # |:foreign_key| in the other LDAP entry covered by class |:class_name|.
-    #
-    # Example:
-    #  belongs_to :groups, :class_name => Group, :foreign_key => memberUid, :local_key => 'uid'
-    #
-    def belongs_to(association_id, options = {})
-      klass = options[:class_name] || association_id.to_s
-      key = options[:foreign_key]  || association_id.to_s + "_id"
-      local_key = options[:local_key] || ''
-      class_eval <<-"end_eval"
-        def #{association_id}(objects = nil)
-          objects = @@config[:return_objects] if objects.nil?
-          local_key = "#{local_key}"
-          local_key = dnattr() if local_key.empty?
-          results = []
-          #{klass}.find_all(:attribute => "#{key}", :value => send(local_key.to_sym), :objects => objects).each do |o|
-            results << o
-          end
-          return results
-        end
-      end_eval
-    end
-
-
-    # has_many
-    #
-    # This defines a method for an extension class expand an 
-    # existing multi-element attribute into ActiveLDAP objects.
-    # This discards any calls which result in entries that
-    # don't exist in LDAP!
-    #
-    # Example:
-    #   has_many :members, :class_name => User, :local_key => memberUid, :foreign_key => 'uid'
-    #
-    # TODO[ENH]: def #{...}=(val) to redefine group membership
-    def has_many(association_id, options = {})
-      klass = options[:class_name] || association_id.to_s
-      key = options[:local_key]  || association_id.to_s + "_id"
-      foreign_key = options[:foreign_key] || ''
-      class_eval <<-"end_eval"
-        def #{association_id}(objects = nil)
-          objects = @@config[:return_objects] if objects.nil?
-          foreign_key = "#{foreign_key}"
-          if foreign_key.empty?
-            foreign_key = dnattr()
-          end
-          results = []
-          unless @data["#{key}"].nil?
-            @data["#{key}"].each do |item|
-              fkey = ""
-              if foreign_key == "dn" and not item.empty?
-                fkey = item.split(',')[0].split('=')[0]
-                item = item.split(',')[0].split('=')[1]
-              end
-              # This will even yield entries that don't necessarily exist
-              if foreign_key != "dn"
-                fkey = foreign_key
-              end
-              #{klass}.find_all(:attribute => fkey, :value => item, :objects => objects).each do |match|
-                results << match
-              end
-            end
-          end
-          return results
-        end
-      end_eval
-    end
-
-  end
-end
-end