activeldap 4.0.5 → 6.1.0

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
@@ -252,6 +296,94 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
+  def test_set_single_valued_attribute_uses_replace
+    make_temporary_user(:simple => true) do |user,|
+      assert_not_nil(user.homeDirectory)
+      assert_not_equal("/home/foo", user.homeDirectory)
+
+      user.homeDirectory = "/home/foo"
+      assert_equal({
+                     :modified => true,
+                     :entries => [
+                       [
+                         :replace,
+                         "homeDirectory",
+                         {"homeDirectory" => ["/home/foo"]},
+                       ]
+                     ]
+                   },
+                   detect_modify(user) {user.save})
+      assert_equal("/home/foo", user.homeDirectory)
+    end
+  end
+
+  def test_set_attribute_uses_add_for_completely_new_value
+    make_temporary_user(:simple => true) do |user,|
+      assert_nil(user.description)
+
+      user.description = "x"
+      assert_equal({
+                     :modified => true,
+                     :entries => [
+                       [:add, "description", {"description" => ["x"]}],
+                     ],
+                   },
+                   detect_modify(user) {user.save})
+      assert_equal("x", user.description)
+    end
+  end
+
+  def test_set_attribute_uses_add_for_added_value
+    make_temporary_user(:simple => true) do |user,|
+      user.description = ["a", "b"]
+      assert(user.save)
+
+      user.description = ["a", "b", "c"]
+      assert_equal({
+                     :modified => true,
+                     :entries => [
+                       [:add, "description", {"description" => ["c"]}],
+                     ],
+                   },
+                   capture = detect_modify(user) {user.save})
+      assert_equal(["a", "b", "c"], user.description)
+    end
+  end
+
+  def test_set_attribute_uses_delete_for_deleted_value
+    make_temporary_user(:simple => true) do |user,|
+      user.description = ["a", "b", "c"]
+      assert(user.save)
+
+      user.description = ["a", "c"]
+      assert_equal({
+                     :modified => true,
+                     :entries => [
+                       [:delete, "description", {"description" => ["b"]}],
+                     ],
+                   },
+                   detect_modify(user) {user.save})
+      assert_equal(["a", "c"], user.description)
+    end
+  end
+
+  def test_set_attribute_uses_delete_for_unset_value
+    make_temporary_user(:simple => true) do |user,|
+      user.description = "x"
+      assert(user.save)
+
+      user.description = nil
+      assert_equal({
+                     :modified => true,
+                     :entries => [
+                       [:delete, "description", {"description" => ["x"]}],
+                     ],
+                   },
+                   detect_modify(user) {user.save})
+      assert_nil(user.description)
+    end
+  end
+
   def test_set_attributes_with_a_blank_value_in_values
     make_temporary_user(:simple => true) do |user,|
       user.attributes = {"description" => ["a", "b", ""]}
@@ -295,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
@@ -354,14 +499,25 @@ class TestBase < Test::Unit::TestCase
 
   def test_save_with_changes
     make_temporary_user do |user, password|
+      cn = user.cn
       user.cn += "!!!"
-      assert_true(detect_modify(user) {user.save})
+      assert_equal({
+                     :modified => true,
+                     :entries => [
+                       [:replace, "cn", {"cn" => ["#{cn}!!!"]}],
+                     ],
+                   },
+                   detect_modify(user) {user.save})
     end
   end
 
   def test_save_without_changes
     make_temporary_user do |user, password|
-      assert_false(detect_modify(user) {user.save})
+      assert_equal({
+                     :modified => false,
+                     :entries => [],
+                   },
+                   detect_modify(user) {user.save})
     end
   end
 
@@ -663,6 +819,43 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
+  class TestInstantiate < self
+    class Person < ActiveLdap::Base
+      ldap_mapping dn_attribute: "cn",
+                   prefix: "ou=People",
+                   scope: :one,
+                   classes: ["top", "person"]
+    end
+
+    class OrganizationalPerson < Person
+      ldap_mapping dn_attribute: "cn",
+                   prefix: "",
+                   classes: ["top", "person", "organizationalPerson"]
+    end
+
+    class ResidentialPerson < Person
+      ldap_mapping dn_attribute: "cn",
+                   prefix: "",
+                   classes: ["top", "person", "residentialPerson"]
+    end
+
+    def test_sub_class
+      make_ou("People")
+      residential_person = ResidentialPerson.new(cn: "John Doe",
+                                                 sn: "Doe",
+                                                 street: "123 Main Street",
+                                                 l: "Anytown")
+      residential_person.save!
+      organizational_person = OrganizationalPerson.new(cn: "Jane Smith",
+                                                       sn: "Smith",
+                                                       title: "General Manager")
+      organizational_person.save!
+      people = Person.all
+      assert_equal([ResidentialPerson, OrganizationalPerson],
+                   people.collect(&:class))
+    end
+  end
+
   def test_reload_of_not_exists_entry
     make_temporary_user do |user,|
       assert_nothing_raised do
@@ -809,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
@@ -1151,23 +1345,30 @@ EOX
 
   private
   def detect_modify(object)
-    modify_called = false
+    modify_called = nil
+    entries = nil
     singleton_class = class << object; self; end
     singleton_class.send(:define_method, :modify_entry) do |*args|
       dn, attributes, options = args
       options ||= {}
       modify_detector = Object.new
       modify_detector.instance_variable_set("@called", false)
+      modify_detector.instance_variable_set("@entries", [])
       def modify_detector.modify(dn, entries, options)
         @called = true
+        @entries = entries
       end
       options[:connection] = modify_detector
       result = super(dn, attributes, options)
       modify_called = modify_detector.instance_variable_get("@called")
+      entries = modify_detector.instance_variable_get("@entries")
       result
     end
     yield
-    modify_called
+    {
+      :modified => modify_called,
+      :entries => entries,
+    }
   end
 
   def assert_to_ldif(entry)

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_callback.rb

@@ -6,10 +6,10 @@ class TestCallback < Test::Unit::TestCase
   priority :must
   def test_new
     initialized_entries = []
-    @group_class.instance_variable_set("@initialized_entries",
-                                       initialized_entries)
     @group_class.module_eval do
-      after_initialize "self.class.instance_variable_get('@initialized_entries') << self"
+      after_initialize do
+        initialized_entries << self
+      end
     end
     assert_equal([], initialized_entries)
     new_group = @group_class.new(:cn => "new-cn")
@@ -22,12 +22,14 @@ class TestCallback < Test::Unit::TestCase
     make_temporary_group do |group|
       found_entries = []
       initialized_entries = []
-      @group_class.instance_variable_set("@found_entries", found_entries)
-      @group_class.instance_variable_set("@initialized_entries",
-                                         initialized_entries)
       @group_class.module_eval do
-        after_find "self.class.instance_variable_get('@found_entries') << self"
-        after_initialize "self.class.instance_variable_get('@initialized_entries') << self"
+        prepend ActiveLdap::Callbacks::CallbackedInstantiatable
+        after_find do
+          found_entries << self
+        end
+        after_initialize do
+          initialized_entries << self
+        end
       end
 
       assert_equal([], found_entries)

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_connection_per_class.rb

@@ -57,6 +57,40 @@ class TestConnectionPerClass < Test::Unit::TestCase
     assert_equal([sub2_base], sub2_class.find(:all).collect(&:dn))
   end
 
+  def test_multi_same_setup_connections
+    make_ou("Sub")
+    sub_class1 = ou_class("ou=Sub")
+    sub_class2 = ou_class("ou=Sub")
+
+    configuration = current_configuration.symbolize_keys
+    configuration[:scope] = :base
+    current_base = configuration[:base]
+    sub_configuration = configuration.dup
+    sub_base = "ou=Sub,#{current_base}"
+    sub_configuration[:base] = sub_base
+
+    sub_class1.setup_connection(sub_configuration)
+    sub_class2.setup_connection(sub_configuration)
+
+    sub_configuration1 = sub_class1.configuration
+    sub_configuration2 = sub_class2.configuration
+
+    assert_not_nil(sub_configuration1)
+    assert_not_nil(sub_configuration2)
+
+    sub_class1.setup_connection(sub_configuration.dup)
+    sub_class1.prefix = nil
+
+    assert_equal([
+                   sub_configuration1,
+                   sub_configuration2,
+                 ],
+                 [
+                   sub_class1.configuration,
+                   sub_class2.configuration,
+                 ])
+  end
+
   def test_bind
     non_anon_class = ou_class("ou=NonAnonymous")
     anon_class = ou_class("ou=Anonymous")

data/test/test_dn.rb

@@ -72,6 +72,13 @@ class TestDN < Test::Unit::TestCase
               "dc = \" l o c a l \" , dc = \"+n,\\\"e\\\";t\"")
   end
 
+  def test_parse_dn_with_spaces_in_attribute_value
+    assert_dn([["o", "xxx "], ["dc", "local"]], "o=xxx\\ ,dc=local")
+    assert_dn([["o", " xxx"], ["dc", "local"]], "o=\\ xxx,dc=local")
+    assert_dn([["o", "xxx yyy"], ["dc", "local"]], "o=xxx\\ yyy,dc=local")
+    assert_dn([["o", " xxx "], ["dc", "local"]], "o=\\ xxx\\ ,dc=local")
+  end
+
   def test_parse_dn_in_rfc2253
     assert_dn([
                {"cn" => "Steve Kille"},

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")
@@ -63,7 +73,8 @@ class TestFind < Test::Unit::TestCase
 
   def test_find_operational_attributes
     make_temporary_user do |user, password|
-      found_user = @user_class.find(user.uid, :attributes => ["*", "+"])
+      found_user = @user_class.find(user.uid,
+                                    :include_operational_attributes => true)
       assert_equal(Time.now.utc.iso8601,
                    found_user.modify_timestamp.utc.iso8601)
     end

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

data/test/test_syntax.rb

@@ -117,6 +117,11 @@ class TestSyntax < Test::Unit::TestCase
                          "19941216103212.345+0900")
       end
 
+      def test_timezone_difference_with_minutes
+        assert_type_cast(Time.parse("2019-02-13 15:54:23 +0530"),
+                         "20190213155423+0530")
+      end
+
       def test_year_month_day_hour_minute
         assert_type_cast(Time.parse("2008/01/07 03:46:00"),
                          "200801070346")