activeldap 5.2.4 → 6.1.0

data/lib/active_ldap.rb

@@ -1,4 +1,3 @@
-require "rubygems"
 require "active_model"
 require "active_support/core_ext"
 

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

@@ -1,6 +1,6 @@
 # Your LDAP server needs to accept 'phonetic' attribute option for test.
 # This is a LDIF file for OpenLDAP to do the configuration.
-# You can use this file by the following command linne on Debian GNU/Linux
+# You can use this file by the following command line on Debian GNU/Linux
 # or Ubuntu:
 #   % sudo -H ldapmodify -Y EXTERNAL -H ldapi:/// -f test/add-phonetic-attribute-options-to-slapd.ldif
 version: 1

data/test/al-test-utils.rb

@@ -23,6 +23,7 @@ module AlTestUtils
       include TemporaryEntry
       include CommandSupport
       include MockLogger
+      include Omittable
     end
   end
 
@@ -39,7 +40,13 @@ module AlTestUtils
       @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")
+      current_config_file = File.expand_path("config.yaml")
+      test_config_file = File.join(@base_dir, "config.yaml")
+      if File.exist?(current_config_file)
+        @config_file = current_config_file
+      else
+        @config_file = test_config_file
+      end
       ActiveLdap::Base.configurations = read_config
     end
 
@@ -175,6 +182,7 @@ module AlTestUtils
       populate_ou
       populate_user_class
       populate_group_class
+      populate_group_of_urls_class
       populate_associations
     end
 
@@ -208,7 +216,7 @@ module AlTestUtils
     end
 
     def populate_ou
-      %w(Users Groups).each do |name|
+      %w(Users Groups GroupOfURLsSet).each do |name|
         make_ou(name)
       end
     end
@@ -239,6 +247,14 @@ module AlTestUtils
       assign_class_name(@group_class, "Group")
     end
 
+    def populate_group_of_urls_class
+      @group_of_urls_class = Class.new(ActiveLdap::Base)
+      @group_of_urls_class.ldap_mapping :prefix => "ou=GroupOfURLsSet",
+                                        :scope => :sub,
+                                        :classes => ["groupOfURLs"]
+      assign_class_name(@group_of_urls_class, "GroupOfURLs")
+    end
+
     def populate_associations
       @user_class.belongs_to :groups, :many => "memberUid"
       @user_class.belongs_to :primary_group,
@@ -273,41 +289,70 @@ module AlTestUtils
       super
       @user_index = 0
       @group_index = 0
+      @group_of_urls_index = 0
+      @temporary_uids = []
+    end
+
+    def teardown
+      @temporary_uids.each do |uid|
+        delete_temporary_user(uid)
+      end
+      super
+    end
+
+    def delete_temporary_user(uid)
+      return unless @user_class.exists?(uid)
+      @user_class.search(:value => uid) do |dn, attribute|
+        @user_class.remove_connection(dn)
+        @user_class.delete(dn)
+      end
+    end
+
+    def build_temporary_user(config={})
+      uid = config[:uid] || "temp-user#{@user_index}"
+      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]
+      user = nil
+      _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?)
+      end
+      [@user_class.find(user.uid), password]
     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)
+      config = config.merge(uid: config[:uid] || "temp-user#{@user_index}")
+      uid = config[:uid]
+      @temporary_uids << uid
+      if block_given?
+        ensure_delete_user(uid) do
+          yield(*build_temporary_user(config))
         end
+      else
+        build_temporary_user(config)
       end
     end
 
@@ -331,15 +376,30 @@ module AlTestUtils
       end
     end
 
+    def make_temporary_group_of_urls(config={})
+      @group_of_urls_index += 1
+      cn = config[:cn] || "temp-group-of-urls-#{@group_of_urls_index}"
+      ensure_delete_group_of_urls(cn) do
+        _wrap_assertion do
+          assert(!@group_of_urls_class.exists?(cn))
+          assert_raise(ActiveLdap::EntryNotFound) do
+            @group_of_urls_class.find(cn)
+          end
+          group_of_urls = @group_of_urls_class.new(cn)
+          assert(group_of_urls.new_entry?)
+          group_of_urls.member_url = config[:member_url]
+          assert(group_of_urls.save!)
+          assert(!group_of_urls.new_entry?)
+          yield(@group_of_urls_class.find(group_of_urls.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
+      delete_temporary_user(uid)
+      @temporary_uids.delete(uid)
     end
 
     def ensure_delete_group(cn)
@@ -348,6 +408,12 @@ module AlTestUtils
       @group_class.delete(cn) if @group_class.exists?(cn)
     end
 
+    def ensure_delete_group_of_urls(cn)
+      yield(cn)
+    ensure
+      @group_of_urls_class.delete(cn) if @group_of_urls_class.exists?(cn)
+    end
+
     def default_uid
       "10000#{@user_index}"
     end
@@ -373,6 +439,10 @@ module AlTestUtils
     end
 
     def run_command(*args, &block)
+      if RUBY_VERSION >= "2.7"
+        omit("Need to fix an optional arguments warning in net-ldap: " +
+            "ruby-ldap/ruby-net-ldap/pull/342")
+      end
       file = Tempfile.new("al-command-support")
       file.open
       file.puts(ActiveLdap::Base.configurations["test"].to_yaml)
@@ -425,4 +495,21 @@ module AlTestUtils
       ActiveLdap::Base.logger = original_logger
     end
   end
+
+  module Omittable
+    def omit_if_jruby(message=nil)
+      return unless RUBY_PLATFORM == "java"
+      omit(message || "This test is not for JRuby")
+    end
+
+    def omit_unless_jruby(message=nil)
+      return if RUBY_PLATFORM == "java"
+      omit(message || "This test is only for JRuby")
+    end
+
+    def omit_if_ldap(message=nil)
+      return if current_configuration[:adapter] == "ldap"
+      omit(message || "This test is not for ruby-ldap")
+    end
+  end
 end

data/test/enable-dynamic-groups.ldif

@@ -0,0 +1,22 @@
+# Your LDAP server needs to support dynamic list for test.
+# This is a LDIF file for OpenLDAP to do the configuration.
+# You can use this file by the following command line on Debian GNU/Linux
+# or Ubuntu:
+#
+#   % sudo -H ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/ldap/schema/dyngroup.ldif
+#   % sudo -H ldapmodify -Y EXTERNAL -H ldapi:/// -f test/enable-dynamic-groups.ldif
+version: 1
+
+# Enable dynlist module
+dn: cn=module{0},cn=config
+changetype: modify
+add: olcModuleLoad
+olcModuleLoad: dynlist
+
+# Set up dynlist overlay
+dn: olcOverlay=dynlist,olcDatabase={1}mdb,cn=config
+changetype: add
+objectClass: olcOverlayConfig
+objectClass: olcDynamicList
+olcOverlay: dynlist
+olcDlAttrSet: groupOfURLs memberURL member

data/test/enable-start-tls.ldif

@@ -1,6 +1,6 @@
 # Your LDAP server needs to support StartTLS when you test StartTLS related
 # feature. This is a LDIF file for OpenLDAP to do the configuration.
-# You can use this file by the following command linne on Debian GNU/Linux
+# You can use this file by the following command line on Debian GNU/Linux
 # or Ubuntu:
 #
 #   % sudo usermod -a -G ssl-cert openldap

data/test/run-test.rb

@@ -2,8 +2,6 @@
 
 $VERBOSE = true
 
-$KCODE = 'u' if RUBY_VERSION < "1.9"
-
 base_dir = File.expand_path(File.dirname(__FILE__))
 top_dir = File.expand_path(File.join(base_dir, ".."))
 lib_dir = File.join(top_dir, "lib")
@@ -11,11 +9,9 @@ test_dir = File.join(top_dir, "test")
 $LOAD_PATH.unshift(lib_dir)
 $LOAD_PATH.unshift(test_dir)
 
-require "rubygems"
 require "bundler/setup"
 
 require "test/unit"
-require "test/unit/notify"
 Test::Unit::Priority.enable
 
 Dir.glob(File.join(test_dir, "**", "test_*.rb")) do |test_file|

data/test/test_base.rb

@@ -5,7 +5,52 @@ require 'al-test-utils'
 class TestBase < Test::Unit::TestCase
   include AlTestUtils
 
+  sub_test_case("follow_referrals") do
+    def test_default
+      make_temporary_user do |user1,|
+        make_temporary_user do |user2,|
+          member_url = ["ldap:///#{user1.base.to_s}??one?(objectClass=person)"]
+          make_temporary_group_of_urls(member_url: member_url) do |group_of_urls|
+            assert_equal([user1.dn, user2.dn],
+                         group_of_urls.attributes["member"])
+          end
+        end
+      end
+    end
+
+    def test_connection_false
+      omit_unless_jruby
+      @group_of_urls_class.setup_connection(
+        current_configuration.merge(follow_referrals: false)
+      )
+      make_temporary_user do |user1,|
+        make_temporary_user do |user2,|
+          member_url = ["ldap:///#{user1.base.to_s}??one?(objectClass=person)"]
+          make_temporary_group_of_urls(member_url: member_url) do |group_of_urls|
+            assert_nil(group_of_urls.attributes["member"])
+          end
+        end
+      end
+    end
+
+    def test_connect_false
+      omit_unless_jruby
+      connection = @group_of_urls_class.connection
+      connection.disconnect!
+      connection.connect(follow_referrals: false)
+      make_temporary_user do |user1,|
+        make_temporary_user do |user2,|
+          member_url = ["ldap:///#{user1.base.to_s}??one?(objectClass=person)"]
+          make_temporary_group_of_urls(member_url: member_url) do |group_of_urls|
+            assert_nil(group_of_urls.attributes["member"])
+          end
+        end
+      end
+    end
+  end
+
   priority :must
+  priority :normal
   def test_search_colon_value
     make_temporary_group(:cn => "temp:group") do |group|
       assert_equal("temp:group", group.cn)
@@ -13,7 +58,6 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_lower_case_object_class
     fixture_file = fixture("lower_case_object_class_schema.rb")
     schema_entries = eval(File.read(fixture_file))
@@ -122,9 +166,9 @@ class TestBase < Test::Unit::TestCase
 
   def test_operational_attributes
     make_temporary_group do |group|
-      dn, attributes = @group_class.search(:attributes => ["*"])[0]
+      _dn, attributes = @group_class.search(:attributes => ["*"])[0]
       normal_attributes = attributes.keys
-      dn, attributes = @group_class.search(:attributes => ["*", "+"])[0]
+      _dn, attributes = @group_class.search(:attributes => ["*", "+"])[0]
       operational_attributes = attributes.keys - normal_attributes
       operational_attribute = operational_attributes[0]
 
@@ -150,13 +194,13 @@ class TestBase < Test::Unit::TestCase
     _ou_class.create("root2")
     assert_equal(["base",
                   "root1", "child1", "child2", "domain", "child3",
-                  "root2"],
-                 _entry_class.find(:all).collect(&:id))
+                  "root2"].sort,
+                 _entry_class.find(:all).collect(&:id).sort)
     assert_raise(ActiveLdap::DeleteError) do
       root1.destroy_all
     end
-    assert_equal(["base", "root1", "domain", "root2"],
-                 _entry_class.find(:all).collect(&:id))
+    assert_equal(["base", "root1", "domain", "root2"].sort,
+                 _entry_class.find(:all).collect(&:id).sort)
   end
 
   def test_delete_mixed_tree_by_instance
@@ -173,13 +217,13 @@ class TestBase < Test::Unit::TestCase
     _ou_class.create("root2")
     assert_equal(["base",
                   "root1", "child1", "child2", "domain", "child3",
-                  "root2"],
-                 _entry_class.find(:all).collect(&:id))
+                  "root2"].sort,
+                 _entry_class.find(:all).collect(&:id).sort)
     assert_raise(ActiveLdap::DeleteError) do
       root1.delete_all
     end
-    assert_equal(["base", "root1", "domain", "root2"],
-                 _entry_class.find(:all).collect(&:id))
+    assert_equal(["base", "root1", "domain", "root2"].sort,
+                 _entry_class.find(:all).collect(&:id).sort)
   end
 
   def test_delete_tree
@@ -189,8 +233,8 @@ class TestBase < Test::Unit::TestCase
     _ou_class.create(:ou => "child1", :parent => root1)
     _ou_class.create(:ou => "child2", :parent => root1)
     _ou_class.create("root2")
-    assert_equal(["base", "root1", "child1", "child2", "root2"],
-                 _ou_class.find(:all).collect(&:ou))
+    assert_equal(["base", "root1", "child1", "child2", "root2"].sort,
+                 _ou_class.find(:all).collect(&:ou).sort)
     _ou_class.delete_all(:base => root1.dn)
     assert_equal(["base", "root2"],
                  _ou_class.find(:all).collect(&:ou))
@@ -217,11 +261,11 @@ class TestBase < Test::Unit::TestCase
                              :classes => ["top"]
     entry_class.dn_attribute = nil
     assert_equal(["base", "root1", "child1", "domain1", "grandchild1",
-                  "child2", "domain2", "root2"],
-                 entry_class.find(:all).collect(&:id))
+                  "child2", "domain2", "root2"].sort,
+                 entry_class.find(:all).collect(&:id).sort)
     entry_class.delete_all(nil, :base => child2.dn)
-    assert_equal(["base", "root1", "child1", "domain1", "grandchild1", "root2"],
-                 entry_class.find(:all).collect(&:id))
+    assert_equal(["base", "root1", "child1", "domain1", "grandchild1", "root2"].sort,
+                 entry_class.find(:all).collect(&:id).sort)
   end
 
   def test_first
@@ -383,6 +427,19 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
+  def test_set_dn_with_unnormalized_dn_attribute_with_forward_slash
+    make_temporary_user do |user,|
+      new_dn = "uid=temp/user1,#{user.class.base}"
+      assert_not_equal(user.dn.to_s, new_dn)
+
+      user.uid = 'temp/user1'
+      assert_equal(user.dn.to_s, new_dn)
+
+      assert_true(user.save!)
+      assert_true(user.class.find(user.uid).update_attributes!(gidNumber: 100069))
+    end
+  end
+
   def test_destroy_with_empty_base_and_prefix_of_class
     make_temporary_user do |user,|
       base = user.class.base
@@ -945,7 +1002,8 @@ class TestBase < Test::Unit::TestCase
     ou_class.ldap_mapping(:dn_attribute => :ou,
                           :prefix => "",
                           :classes => ["top", "organizationalUnit"])
-    assert_equal(["ou=Groups,#{current_configuration['base']}",
+    assert_equal(["ou=GroupOfURLsSet,#{current_configuration['base']}",
+                  "ou=Groups,#{current_configuration['base']}",
                   "ou=Users,#{current_configuration['base']}"],
                  ou_class.find(:all).collect(&:dn).collect(&:to_s).sort)
   end

data/test/test_base_per_instance.rb

@@ -9,13 +9,45 @@ class TestBasePerInstance < Test::Unit::TestCase
   end
 
   priority :must
+  def test_dn_with_sub_base_first
+    sub_user = @user_class.new(dn: "uid=user1,ou=Sub,#{@user_class.base}",
+                               uid: "user1")
+    # Order is important. #base should be called before #dn.
+    base = sub_user.base.to_s
+    dn = sub_user.dn.to_s
+    assert_equal([
+                   "ou=Sub,#{@user_class.base}",
+                   "uid=user1,ou=Sub,#{@user_class.base}",
+                 ],
+                 [
+                   base,
+                   dn,
+                 ])
+  end
+
+  def test_dn_with_sub_base_last
+    sub_user = @user_class.new(uid: "user1",
+                               dn: "uid=user1,ou=Sub,#{@user_class.base}")
+    # Order is important. #base should be called before #dn.
+    base = sub_user.base.to_s
+    dn = sub_user.dn.to_s
+    assert_equal([
+                   "ou=Sub,#{@user_class.base}",
+                   "uid=user1,ou=Sub,#{@user_class.base}",
+                 ],
+                 [
+                   base,
+                   dn,
+                 ])
+  end
+
+  priority :normal
   def test_set_base
     guest = @user_class.new("guest")
     guest.base = "ou=Sub"
     assert_equal("uid=guest,ou=Sub,#{@user_class.base}", guest.dn)
   end
 
-  priority :normal
   def test_dn_is_base
     entry_class = Class.new(ActiveLdap::Base)
     entry_class.ldap_mapping :prefix => "",

data/test/test_connection.rb

@@ -3,6 +3,7 @@ require 'al-test-utils'
 class TestConnection < Test::Unit::TestCase
   include AlTestUtils::Config
   include AlTestUtils::MockLogger
+  include AlTestUtils::Omittable
 
   def setup
     super
@@ -23,6 +24,9 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_retry_limit_0_with_nonexistent_host_with_timeout
+    omit_if_ldap("this test will take a long time...")
+    omit_if_jruby("JNI adapter returns connection error immediately. " +
+                  "So timeout isn't invoked.")
     config = current_configuration.merge("host" => "192.168.29.29",
                                          "retry_limit" => 0,
                                          "timeout" => 1)

data/test/test_entry.rb

@@ -11,6 +11,7 @@ class TestEntry < Test::Unit::TestCase
         all_entries = [ActiveLdap::Base.base]
         all_entries += [user.dn, user.base]
         all_entries += [group.dn, group.base]
+        all_entries += [@group_of_urls_class.base]
         assert_equal(all_entries.sort,
                      ActiveLdap::Entry.all.collect(&:dn).sort)
       end

data/test/test_find.rb

@@ -3,7 +3,18 @@ require 'al-test-utils'
 class TestFind < Test::Unit::TestCase
   include AlTestUtils
 
-  priority :must
+  def test_find_paged
+    page_size = 126
+    n_users = page_size + 1
+    uids = n_users.times.collect do
+      user, _password = make_temporary_user
+      user.uid
+    end
+    users = @user_class.find(:all, page_size: page_size)
+    assert_equal(uids.sort,
+                 users.collect(&:uid).sort)
+  end
+
   def test_find_with_dn
     make_temporary_user do |user,|
       assert_equal(user.dn, @user_class.find(user.dn).dn)
@@ -11,7 +22,6 @@ class TestFind < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_find_with_special_value_prefix
     # \2C == ','
     make_ou("a\\2Cb,ou=Users")

data/test/test_supported_control.rb

@@ -17,7 +17,7 @@ class TestSupportedControl < Test::Unit::TestCase
     end
 
     def test_false
-      assert_true(paged_results?(ActiveLdap::LdapControls::PAGED_RESULTS))
+      assert_false(paged_results?(ActiveLdap::LdapControls::ASSERTION))
     end
   end
 end