activeldap 5.2.4 → 6.0.0

data/lib/active_ldap/human_readable.rb

@@ -17,11 +17,12 @@ module ActiveLdap
         if attribute_or_name.is_a?(Schema::Attribute)
           name = attribute_or_name.name
         else
-          attribute = schema.attribute(attribute_or_name.to_s)
+          attribute_name = attribute_or_name.to_s
+          attribute = schema.attribute(attribute_name)
           return nil if attribute.id.nil?
-          if attribute.name == attribute_or_name or
-              attribute.aliases.include?(attribute_or_name.to_s)
-            name = attribute_or_name
+          if attribute.name == attribute_name or
+              attribute.aliases.include?(attribute_name)
+            name = attribute_name
           else
             return nil
           end

data/lib/active_ldap/operations.rb

@@ -22,9 +22,23 @@ module ActiveLdap
     end
 
     module Common
-      VALID_SEARCH_OPTIONS = [:attribute, :value, :filter, :prefix,
-                              :classes, :scope, :limit, :attributes,
-                              :sort_by, :order, :connection, :base, :offset]
+      VALID_SEARCH_OPTIONS = [
+        :attribute,
+        :value,
+        :filter,
+        :prefix,
+        :classes,
+        :scope,
+        :limit,
+        :attributes,
+        :sort_by,
+        :order,
+        :connection,
+        :base,
+        :offset,
+        :use_paged_results,
+        :page_size,
+      ]
 
       def search(options={}, &block)
         validate_search_options(options)
@@ -62,6 +76,8 @@ module ActiveLdap
           :attributes => requested_attributes,
           :sort_by => options[:sort_by] || sort_by,
           :order => options[:order] || order,
+          :use_paged_results => options[:use_paged_results],
+          :page_size => options[:page_size],
         }
         options[:connection] ||= connection
         values = []
@@ -96,10 +112,11 @@ module ActiveLdap
         }
 
         attribute = attr || ensure_search_attribute
+        escaped_value = DN.escape_value(value)
         options_for_non_leaf = {
           :attribute => attr,
           :value => value,
-          :prefix => ["#{attribute}=#{value}", prefix].compact.join(","),
+          :prefix => ["#{attribute}=#{escaped_value}", prefix].compact.join(","),
           :limit => 1,
           :scope => :base,
         }

data/lib/active_ldap/version.rb

@@ -1,3 +1,3 @@
 module ActiveLdap
-  VERSION = "5.2.4"
+  VERSION = "6.0.0"
 end

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
 
@@ -273,41 +280,69 @@ module AlTestUtils
       super
       @user_index = 0
       @group_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
 
@@ -334,12 +369,8 @@ module AlTestUtils
     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)
@@ -373,6 +404,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 +460,16 @@ 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_if_ldap(message=nil)
+      return unless current_configuration[:adapter] == "ldap"
+      omit(message || "This test is not for ruby-ldap")
+    end
+  end
 end

data/test/test_base.rb

@@ -150,13 +150,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 +173,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 +189,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 +217,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

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_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

data/test/test_validation.rb

@@ -52,8 +52,8 @@ class TestValidation < Test::Unit::TestCase
         user1.id = user2.id
         assert_false(user1.save)
 
-        format = la_('distinguishedName').humanize
-        format  << ' ' << _("is duplicated: %s")
+        format = human_attribute_name("distinguishedName")
+        format << " " << _("is duplicated: %s")
         assert_equal([format % [user2.dn.to_s]],
                      user1.errors.full_messages)
       end
@@ -66,8 +66,8 @@ class TestValidation < Test::Unit::TestCase
       user.jpeg_photo = "XXX"
       assert_not_predicate(user, :save)
 
-      format = la_('jpegPhoto').humanize
-      format << ' '  << _("has invalid format: %s: required syntax: %s: %s")
+      format = human_attribute_name('jpegPhoto')
+      format << " "  << _("has invalid format: %s: required syntax: %s: %s")
       arguments = [_("<binary-value>"),
                    lsd_("1.3.6.1.4.1.1466.115.121.1.28"),
                    _("invalid JPEG format")]
@@ -112,8 +112,8 @@ class TestValidation < Test::Unit::TestCase
     reason = _("attribute value is missing")
     invalid_format = _("%s is invalid distinguished name (DN): %s")
     invalid_message = invalid_format % ["uid==,#{user.class.base}", reason]
-    format = la_('distinguishedName').humanize
-    format << ' ' << _("is invalid: %s")
+    format = human_attribute_name("distinguishedName")
+    format << " " << _("is invalid: %s")
     message = format % invalid_message
     assert_equal([message],
                  user.errors.full_messages.find_all {|m| /DN/ =~ m})
@@ -126,8 +126,8 @@ class TestValidation < Test::Unit::TestCase
       reason = _("attribute value is missing")
       invalid_format = _("%s is invalid distinguished name (DN): %s")
       invalid_message = invalid_format % ["uid==,#{user.class.base}", reason]
-      format = la_('distinguishedName').humanize
-      format << ' ' << _("is invalid: %s")
+      format = human_attribute_name("distinguishedName")
+      format << " " << _("is invalid: %s")
       message = format % invalid_message
       assert_equal([message], user.errors.full_messages)
     end
@@ -138,8 +138,8 @@ class TestValidation < Test::Unit::TestCase
       assert(user.valid?)
       user.uid_number = ""
       assert(!user.valid?)
-      format = la_('uidNumber').humanize
-      format << ' ' << _("is required attribute by objectClass '%s'")
+      format = human_attribute_name("uidNumber")
+      format << " " << _("is required attribute by objectClass '%s'")
       blank_message = format % loc_("posixAccount")
       assert_equal([blank_message], user.errors.full_messages)
     end
@@ -150,8 +150,8 @@ class TestValidation < Test::Unit::TestCase
       assert(user.save)
       user.class.excluded_classes = ['person']
       assert(!user.save)
-      format = la_("objectClass").humanize
-      format << ' ' << n_("has excluded value: %s",
+      format = human_attribute_name("objectClass")
+      format << " " << n_("has excluded value: %s",
                           "has excluded values: %s",
                           1)
       message = format % loc_("person")
@@ -222,8 +222,8 @@ class TestValidation < Test::Unit::TestCase
     assert(ou_class.new("YYY").save)
     ou = ou_class.new("YYY")
     assert(!ou.save)
-    format = la_("distinguishedName").humanize
-    format << ' ' << _("is duplicated: %s")
+    format = human_attribute_name("distinguishedName")
+    format << " " << _("is duplicated: %s")
     message = format % ou.dn
     assert_equal([message], ou.errors.full_messages)
   end
@@ -259,12 +259,16 @@ class TestValidation < Test::Unit::TestCase
   end
 
   private
+  def human_attribute_name(name)
+    la_(name).dup
+  end
+
   def assert_invalid_value(name, formatted_value, syntax, reason, model, option)
     syntax_description = lsd_(syntax)
     assert_not_nil(syntax_description)
     params = [formatted_value, syntax_description, reason]
     params.unshift(option) if option
-    localized_name = la_(name).humanize
+    localized_name = human_attribute_name(name)
     format = localized_name << ' '
     if option
       format << _("(%s) has invalid format: %s: required syntax: %s: %s")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeldap
 version: !ruby/object:Gem::Version
-  version: 5.2.4
+  version: 6.0.0
 platform: ruby
 authors:
 - Will Drewry
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-26 00:00:00.000000000 Z
+date: 2020-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -96,7 +96,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: kramdown
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -110,7 +110,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: packnga
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -124,7 +124,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit-notify
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -138,7 +138,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -152,7 +152,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: RedCloth
+  name: test-unit-notify
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -166,7 +166,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: packnga
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -196,16 +196,15 @@ files:
 - COPYING
 - Gemfile
 - LICENSE
-- README.textile
 - TODO
 - benchmark/README.md
 - benchmark/bench-backend.rb
 - benchmark/bench-instantiate.rb
 - benchmark/config.yaml.sample
-- doc/text/development.textile
-- doc/text/news.textile
-- doc/text/rails.textile
-- doc/text/tutorial.textile
+- doc/text/development.md
+- doc/text/news.md
+- doc/text/rails.md
+- doc/text/tutorial.md
 - examples/config.yaml.example
 - examples/example.der
 - examples/example.jpg
@@ -359,8 +358,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: ruby-activeldap
-rubygems_version: 2.7.6.2
+rubygems_version: 3.2.0.pre1
 signing_key: 
 specification_version: 4
 summary: ActiveLdap is a object-oriented API to LDAP