ruby-activeldap 0.8.2 → 0.8.3

data/test/test_adapter.rb

@@ -12,6 +12,17 @@ class TestAdapter < Test::Unit::TestCase
   priority :must
 
   priority :normal
+  def test_filter_with_escaped_character
+    assert_parse_filter("(uid=Alice\\28Bob)", {:uid => "Alice(Bob"})
+    assert_parse_filter("(uid=Alice\\29Bob)", {:uid => "Alice)Bob"})
+    assert_parse_filter("(uid=Alice\\29Bob\\28)", {:uid => "Alice)Bob("})
+    assert_parse_filter("(uid=Alice\\28\\29Bob)", {:uid => "Alice()Bob"})
+    assert_parse_filter("(uid=Alice*Bob)", {:uid => "Alice*Bob"})
+    assert_parse_filter("(uid=Alice\\2ABob)", {:uid => "Alice**Bob"})
+    assert_parse_filter("(uid=Alice\\2A*\\5CBob)", {:uid => "Alice***\\Bob"})
+    assert_parse_filter("(uid=Alice\\5C\\2A*Bob)", {:uid => "Alice\\***Bob"})
+  end
+
   def test_empty_filter
     assert_parse_filter(nil, nil)
     assert_parse_filter(nil, "")
@@ -64,6 +75,12 @@ class TestAdapter < Test::Unit::TestCase
                         [:and,
                          [:and, {"gidNumber"=>["100001"]}],
                          [:or, {"uid"=>["temp-user1", "temp-user2"]}]])
+    assert_parse_filter("(&(gidNumber=100001)" +
+                        "(objectClass=person)(objectClass=posixAccount))",
+                        [:and,
+                         [:or, ["gidNumber", "100001"]],
+                         ["objectClass", "person"],
+                         ["objectClass", "posixAccount"]])
   end
 
   def test_invalid_operator

data/test/test_associations.rb

@@ -4,6 +4,25 @@ class TestAssociations < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+
+  priority :normal
+  def test_belongs_to_many_with_dn_key
+    @user_class.belongs_to :groups, :many => "memberUid", :foreign_key => "dn"
+    @user_class.set_associated_class(:groups, @group_class)
+    @group_class.has_many :members, :wrap => "memberUid", :primary_key => "dn"
+    @group_class.set_associated_class(:members, @user_class)
+    make_temporary_group do |group|
+      make_temporary_user do |user1,|
+        make_temporary_user do |user2,|
+          group.members = [user1, user2]
+          assert(group.save)
+          assert_equal([group.cn], user1.groups.collect(&:cn))
+          assert_equal([group.cn], user2.groups.collect(&:cn))
+        end
+      end
+    end
+  end
+
   def test_belongs_to_many_delete
     make_temporary_group do |group1|
       make_temporary_group do |group2|

data/test/test_attributes.rb

@@ -4,6 +4,8 @@ class TestAttributes < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+
+  priority :normal
   def test_to_real_attribute_name
     user = @user_class.new("user")
     assert_nil(user.__send__(:to_real_attribute_name, "objectclass"))
@@ -11,7 +13,6 @@ class TestAttributes < Test::Unit::TestCase
                  user.__send__(:to_real_attribute_name, "objectclass", true))
   end
 
-  priority :normal
   def test_protect_object_class_from_mass_assignment
     classes = @user_class.required_classes + ["inetOrgPerson"]
     user = @user_class.new(:uid => "XXX", :object_class => classes)

data/test/test_base.rb

@@ -4,6 +4,34 @@ class TestBase < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+
+  priority :normal
+  def test_dn_attribute_per_instance
+    user = @user_class.new
+    assert_equal("uid", user.dn_attribute)
+    assert_nil(user.uid)
+
+    user.dn = "cn=xxx"
+    assert_equal("cn", user.dn_attribute)
+    assert_nil(user.uid)
+    assert_equal("xxx", user.cn)
+    assert_equal("cn=xxx,#{@user_class.base}", user.dn)
+
+    assert_equal("uid", @user_class.new.dn_attribute)
+
+    user.dn = "ZZZ"
+    assert_equal("cn", user.dn_attribute)
+    assert_nil(user.uid)
+    assert_equal("ZZZ", user.cn)
+    assert_equal("cn=ZZZ,#{@user_class.base}", user.dn)
+
+    user.dn = "uid=aaa"
+    assert_equal("uid", user.dn_attribute)
+    assert_equal("aaa", user.uid)
+    assert_equal("ZZZ", user.cn)
+    assert_equal("uid=aaa,#{@user_class.base}", user.dn)
+  end
+
   def test_case_insensitive_nested_ou
     ou_class("ou=Users").new("Sub").save!
     make_temporary_user(:uid => "test-user,ou=SUB") do |user, password|
@@ -14,7 +42,6 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_nested_ou
     make_ou("units")
     units = ou_class("ou=units")

data/test/test_base_per_instance.rb

@@ -9,6 +9,8 @@ class TestBasePerInstance < Test::Unit::TestCase
   end
 
   priority :must
+
+  priority :normal
   def test_loose_dn
     user = @user_class.new("test-user , ou = Sub")
     assert_equal("uid=test-user,ou=Sub,#{@user_class.base}", user.dn)
@@ -17,7 +19,6 @@ class TestBasePerInstance < Test::Unit::TestCase
     assert_equal("uid=test-user,ou=Sub,#{@user_class.base}", user.dn)
   end
 
-  priority :normal
   def test_exists?
     make_temporary_user(:uid => "test-user,ou=Sub") do |user, password|
       assert(@user_class.exists?(user.uid))

data/test/test_callback.rb

@@ -4,6 +4,8 @@ class TestCallback < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+
+  priority :normal
   def test_callback_after_find_and_after_initialize
     make_temporary_group do |group|
       found_entries = []
@@ -30,6 +32,4 @@ class TestCallback < Test::Unit::TestCase
                    initialized_entries.collect {|g| g.cn}.sort)
     end
   end
-
-  priority :normal
 end

data/test/test_connection.rb

@@ -14,6 +14,8 @@ class TestConnection < Test::Unit::TestCase
   end
 
   priority :must
+
+  priority :normal
   def test_bind_format_check
     connector = Class.new(ActiveLdap::Base)
     assert(!connector.connected?)
@@ -30,7 +32,6 @@ class TestConnection < Test::Unit::TestCase
     assert_equal("Unknown key(s): bind_format", exception.message)
   end
 
-  priority :normal
   def test_can_reconnect?
     assert(!ActiveLdap::Base.connected?)
 

data/test/test_connection_per_dn.rb

@@ -0,0 +1,81 @@
+require 'al-test-utils'
+
+class TestConnectionPerDN < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+
+  priority :normal
+  def test_establish_connection
+    make_temporary_user do |user, password|
+      assert_equal(user.class.connection, user.connection)
+      assert_raises(ActiveLdap::AuthenticationError) do
+        user.establish_connection(:bind_dn => nil,
+                                  :allow_anonymous => false,
+                                  :retry_limit => 0)
+      end
+      assert_equal(user.class.connection, user.connection)
+
+      assert_nothing_raised do
+        user.establish_connection(:bind_dn => nil,
+                                  :allow_anonymous => true)
+      end
+      assert_not_equal(user.class.connection, user.connection)
+
+      assert_equal(user.connection, user.class.find(user.dn).connection)
+      assert_equal(user.connection, user.find(user.dn).connection)
+    end
+  end
+
+  def test_find
+    make_temporary_user do |user, password|
+      make_temporary_user do |user2, password2|
+        user.establish_connection(:bind_dn => user.dn,
+                                  :password => password)
+        assert_not_equal(user.class.connection, user.connection)
+
+        found_user2 = user.find(user2.dn)
+        assert_not_equal(user2.connection, found_user2.connection)
+        assert_equal(user.connection, found_user2.connection)
+
+        assert_equal(found_user2.class.connection,
+                     found_user2.class.find(found_user2.dn).connection)
+
+        found_user2.establish_connection(:bind_dn => user2.dn,
+                                         :password => password2)
+        assert_not_equal(user.connection, found_user2.connection)
+        assert_equal(user2.connection, found_user2.connection)
+      end
+    end
+  end
+
+  def test_associations
+    make_temporary_user do |user, password|
+      make_temporary_group do |group1|
+        make_temporary_group do |group2|
+          user.groups = [group1]
+          assert_equal(group1.connection, user.connection)
+
+          user.establish_connection(:bind_dn => user.dn,
+                                    :password => password)
+          assert_not_equal(user.class.connection, user.connection)
+          assert_not_equal(group1.connection, user.connection)
+          assert_equal(user.groups[0].connection, user.connection)
+
+          assert_raise(ActiveLdap::LdapError::InsufficientAccess) do
+            user.groups << group2
+          end
+          assert_equal([group1.cn], user.groups.collect(&:cn))
+
+          assert_not_equal(group1.connection, user.connection)
+          assert_equal(user.groups[0].connection, user.connection)
+
+          found_user = user.class.find(user.dn)
+          assert_equal(user.connection, found_user.connection)
+          assert_equal(found_user.connection,
+                       found_user.groups[0].connection)
+        end
+      end
+    end
+  end
+end

data/test/test_dn.rb

@@ -10,11 +10,12 @@ class TestDN < Test::Unit::TestCase
   end
 
   priority :must
+
+  priority :normal
   def test_case_insensitive_dn_minus
     assert_dn_minus("dc=xxx", "dc=xxx,dc=LoCaL,dc=net", "dc=LOCAL,dc=net")
   end
 
-  priority :normal
   def test_dn_hash
     dn1 = ActiveLdap::DN.parse("o=xxx,dc=local,dc=net")
     dn2 = ActiveLdap::DN.parse("O = xxx , DC = local , DC = net")
@@ -135,7 +136,7 @@ class TestDN < Test::Unit::TestCase
     end
     assert_not_nil(exception)
     assert_equal(dn, exception.dn)
-    assert_equal(reason, exception.reason)
+    assert_equal(_(reason), exception.reason)
   end
 
   def assert_dn_parser_collect_pairs(expected, source)

data/test/test_find.rb

@@ -4,6 +4,41 @@ class TestFind < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+
+  priority :normal
+  def test_find_with_limit
+    make_temporary_user(:uid => "user1") do |user1,|
+      make_temporary_user(:uid => "user2") do |user2,|
+        make_temporary_user(:uid => "user3") do |user3,|
+          users = @user_class.find(:all)
+          assert_equal(["user1", "user2", "user3"].sort,
+                       users.collect {|u| u.uid}.sort)
+
+          users = @user_class.find(:all, :limit => 2)
+          assert_operator([["user1", "user2"].sort,
+                           ["user2", "user3"].sort,
+                           ["user3", "user1"].sort],
+                          :include?,
+                          users.collect {|u| u.uid}.sort)
+
+          users = @user_class.find(:all, :limit => 1)
+          assert_operator([["user1"], ["user2"], ["user3"]],
+                          :include?,
+                          users.collect {|u| u.uid})
+        end
+      end
+    end
+  end
+
+  def test_find_all_with_dn_attribute_value
+    make_temporary_user(:uid => "user1") do |user1,|
+      make_temporary_user(:uid => "user2") do |user2,|
+        assert_equal(["user1"],
+                     @user_class.find(:all, "*1").collect {|u| u.uid})
+      end
+    end
+  end
+
   def test_find_with_sort
     make_temporary_user(:uid => "user1") do |user1,|
       make_temporary_user(:uid => "user2") do |user2,|
@@ -25,7 +60,6 @@ class TestFind < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_split_search_value
     assert_split_search_value([nil, "test-user", nil], "test-user")
     assert_split_search_value([nil, "test-user", "ou=Sub"], "test-user,ou=Sub")

data/test/test_object_class.rb

@@ -4,6 +4,18 @@ class TestObjectClass < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+
+  priority :normal
+  def test_case_insensitive_match
+    assert_nothing_raised do
+      @group_class.instantiate(["cn=test-group,#{@group_class.base}",
+                                {
+                                  :cn => "test-group",
+                                  :objectClass => ["TOP", "posixgroup"],
+                                }])
+    end
+  end
+
   def test_ensure_recommended_classes
     make_temporary_group do |group|
       added_class = "labeledURIObject"
@@ -20,7 +32,6 @@ class TestObjectClass < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_unknown_object_class
     make_temporary_group do |group|
       assert_raises(ActiveLdap::ObjectClassError) do

data/test/test_reflection.rb

@@ -15,7 +15,7 @@ class TestReflection < Test::Unit::TestCase
 
   def test_respond_to?
     make_temporary_user do |user, password|
-      attributes = user.must + user.may
+      attributes = (user.must + user.may).collect(&:name)
       _wrap_assertion do
         attributes.each do |name|
           assert(user.respond_to?(name), name)
@@ -59,7 +59,8 @@ class TestReflection < Test::Unit::TestCase
     end
 
     make_temporary_user do |user, password|
-      attributes = user.must + user.may - ["objectClass"]
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes -= ["objectClass"]
       assert_equal([], attributes - user.methods)
       assert_equal([], attributes - user.methods(false))
 
@@ -68,7 +69,8 @@ class TestReflection < Test::Unit::TestCase
 
     make_temporary_user do |user, password|
       user.remove_class("inetOrgPerson")
-      attributes = user.must + user.may - ["objectClass"]
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes -= ["objectClass"]
       assert_equal([], attributes - user.methods)
       assert_equal([], attributes - user.methods(false))
 
@@ -76,7 +78,8 @@ class TestReflection < Test::Unit::TestCase
     end
 
     make_temporary_user do |user, password|
-      attributes = user.must + user.may - ["objectClass"]
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes -= ["objectClass"]
       attributes = attributes.collect {|x| x.downcase}
       assert_not_equal([], attributes - user.methods)
       assert_not_equal([], attributes - user.methods(false))
@@ -91,7 +94,8 @@ class TestReflection < Test::Unit::TestCase
     end
 
     make_temporary_user do |user, password|
-      attributes = user.must + user.may - ["objectClass"]
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes -= ["objectClass"]
       attributes = attributes.collect do |x|
         Inflector.underscore(x)
       end
@@ -109,7 +113,8 @@ class TestReflection < Test::Unit::TestCase
 
     make_temporary_user do |user, password|
       user.remove_class("inetOrgPerson")
-      attributes = user.must + user.may - ["objectClass"]
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes -= ["objectClass"]
       attributes = attributes.collect do |x|
         Inflector.underscore(x)
       end
@@ -159,13 +164,14 @@ class TestReflection < Test::Unit::TestCase
   def collect_attributes(object_classes, with_aliases=true)
     attributes = []
     object_classes.each do |object_class|
-      attrs = ActiveLdap::Base.schema.class_attributes(object_class)
+      object_klass = ActiveLdap::Base.schema.object_class(object_class)
       if with_aliases
-        (attrs[:must] + attrs[:may]).each do |name|
-          attributes.concat(ActiveLdap::Base.schema.attribute_aliases(name))
+        (object_klass.must + object_klass.may).each do |attribute|
+          attributes << attribute.name
+          attributes.concat(attribute.aliases)
         end
       else
-        attributes.concat(attrs[:must] + attrs[:may])
+        attributes.concat((object_klass.must + object_klass.may).collect(&:name))
       end
     end
     attributes

data/test/test_schema.rb

@@ -2,6 +2,134 @@ require 'al-test-utils'
 
 class TestSchema < Test::Unit::TestCase
   priority :must
+
+  def test_super_class?
+    group = 'objectClasses'
+    entry = {
+      group => [
+                "( 2.5.6.6 NAME 'person' DESC 'RFC2256: a person' SUP " +
+                "top STRUCTURAL MUST ( sn $ cn ) MAY ( userPassword $ " +
+                "telephoneNumber $ seeAlso $ description ) )",
+
+                "( 2.5.6.7 NAME 'organizationalPerson' DESC 'RFC2256: " +
+                "an organizational person' SUP person STRUCTURAL MAY ( " +
+                "title $ x121Address $ registeredAddress $ " +
+                "destinationIndicator $ preferredDeliveryMethod $ " +
+                "telexNumber $ teletexTerminalIdentifier $ telephoneNumber " +
+                "$ internationaliSDNNumber $ facsimileTelephoneNumber $ " +
+                "street $ postOfficeBox $ postalCode $ postalAddress $ " +
+                "physicalDeliveryOfficeName $ ou $ st $ l ) )",
+
+                "( 2.16.840.1.113730.3.2.2 NAME 'inetOrgPerson' DESC " +
+                "'RFC2798: Internet Organizational Person' SUP " +
+                "organizationalPerson STRUCTURAL MAY ( audio $ " +
+                "businessCategory $ carLicense $ departmentNumber $ " +
+                "displayName $ employeeNumber $ employeeType $ givenName " +
+                "$ homePhone $ homePostalAddress $ initials $ jpegPhoto " +
+                "$ labeledURI $ mail $ manager $ mobile $ o $ pager $ " +
+                "photo $ roomNumber $ secretary $ uid $ userCertificate $ " +
+                "x500UniqueIdentifier $ preferredLanguage $ " +
+                "userSMIMECertificate $ userPKCS12 ) )",
+               ]
+    }
+    schema = ActiveLdap::Schema.new(entry)
+
+    person = schema.object_class('person')
+    organizational_person = schema.object_class("organizationalPerson")
+    inet_org_person = schema.object_class("inetOrgPerson")
+
+    assert_equal([false, false, false],
+                 [person.super_class?(person),
+                   person.super_class?(organizational_person),
+                   person.super_class?(inet_org_person)])
+
+    assert_equal([true, false, false],
+                 [organizational_person.super_class?(person),
+                  organizational_person.super_class?(organizational_person),
+                  organizational_person.super_class?(inet_org_person)])
+
+    assert_equal([true, true, false],
+                 [inet_org_person.super_class?(person),
+                  inet_org_person.super_class?(organizational_person),
+                  inet_org_person.super_class?(inet_org_person)])
+  end
+
+  priority :normal
+  def test_duplicate_schema
+    sasNMASProductOptions_schema =
+      "( 2.16.840.1.113719.1.39.42.1.0.38 NAME 'sasNMASProductOptions' " +
+      "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40{64512} SINGLE-VALUE " +
+      "X-NDS_PUBLIC_READ '1' )"
+    rADIUSActiveConnections_schema =
+      "( 2.16.840.1.113719.1.39.42.1.0.38 NAME 'rADIUSActiveConnections' " +
+      "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40{64512} X-NDS_NAME " +
+      "'RADIUS:ActiveConnections' X-NDS_NOT_SCHED_SYNC_IMMEDIATE '1' )"
+
+    sasNMASProductOptions = 'sasNMASProductOptions'
+    rADIUSActiveConnections = 'rADIUSActiveConnections'
+    sasNMASProductOptions_aliases =
+      [sasNMASProductOptions, []]
+    rADIUSActiveConnections_aliases =
+      [rADIUSActiveConnections, []]
+    sas_radius_aliases = [sasNMASProductOptions, [rADIUSActiveConnections]]
+    radius_sas_aliases = [rADIUSActiveConnections, [sasNMASProductOptions]]
+
+    assert_attribute_aliases([sasNMASProductOptions_aliases],
+                             [sasNMASProductOptions],
+                             [sasNMASProductOptions_schema],
+                             false)
+    assert_attribute_aliases([rADIUSActiveConnections_aliases],
+                             [rADIUSActiveConnections],
+                             [rADIUSActiveConnections_schema],
+                             false)
+
+    assert_attribute_aliases([sasNMASProductOptions_aliases,
+                              sas_radius_aliases],
+                             [sasNMASProductOptions,
+                              rADIUSActiveConnections],
+                             [sasNMASProductOptions_schema,
+                              rADIUSActiveConnections_schema],
+                             false)
+    assert_attribute_aliases([rADIUSActiveConnections_aliases,
+                              radius_sas_aliases],
+                             [rADIUSActiveConnections,
+                              sasNMASProductOptions],
+                             [rADIUSActiveConnections_schema,
+                              sasNMASProductOptions_schema],
+                             false)
+
+    assert_attribute_aliases([sas_radius_aliases,
+                              sas_radius_aliases],
+                             [rADIUSActiveConnections,
+                              sasNMASProductOptions],
+                             [sasNMASProductOptions_schema,
+                              rADIUSActiveConnections_schema],
+                             false)
+    assert_attribute_aliases([radius_sas_aliases,
+                              radius_sas_aliases],
+                             [sasNMASProductOptions,
+                              rADIUSActiveConnections],
+                             [rADIUSActiveConnections_schema,
+                              sasNMASProductOptions_schema],
+                             false)
+
+    assert_attribute_aliases([sas_radius_aliases,
+                              sas_radius_aliases],
+                             [sasNMASProductOptions,
+                              rADIUSActiveConnections],
+                             [sasNMASProductOptions_schema,
+                              rADIUSActiveConnections_schema],
+                             true)
+    assert_attribute_aliases([radius_sas_aliases,
+                              radius_sas_aliases],
+                             [rADIUSActiveConnections,
+                              sasNMASProductOptions],
+                             [rADIUSActiveConnections_schema,
+                              sasNMASProductOptions_schema],
+                             true)
+  end
+
+  priority :normal
   def test_empty_schema
     assert_make_schema_with_empty_entries(nil)
     assert_make_schema_with_empty_entries({})
@@ -13,7 +141,6 @@ class TestSchema < Test::Unit::TestCase
     assert_equal([], schema["attributeTypes", "cn", "DESC"])
   end
 
-  priority :normal
   def test_attribute_name_with_under_score
     top_schema =
       "( 2.5.6.0 NAME 'Top' STRUCTURAL MUST objectClass MAY ( " +
@@ -244,7 +371,7 @@ class TestSchema < Test::Unit::TestCase
 
     schema = ActiveLdap::Schema.new({"attributeTypes" => [jpeg_photo_schema],
                                      "ldapSyntaxes" => [jpeg_schema]})
-    assert(schema.binary?("jpegPhoto"))
+    assert(schema.attribute("jpegPhoto").binary?)
   end
 
   private
@@ -270,4 +397,16 @@ class TestSchema < Test::Unit::TestCase
                             "DESC"])
     assert_equal([], schema["objectClasses", "posixAccount", "MUST"])
   end
+
+  def assert_attribute_aliases(expected, keys, schemata, ensure_parse)
+    group = 'attributeTypes'
+    entry = {group => schemata}
+    schema = ActiveLdap::Schema.new(entry)
+    schema.send(:ensure_parse, group) if ensure_parse
+    result = keys.collect do |key|
+      attribute = schema.attribute(key)
+      [attribute.name, attribute.aliases]
+    end
+    assert_equal(expected, result)
+  end
 end