ldaptic 0.2.0

data/test/ldaptic_active_model_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(File.expand_path(__FILE__)),'test_helper')
+require 'ldaptic'
+require File.join(File.dirname(File.expand_path(__FILE__)),'/mock_adapter')
+require 'active_model'
+
+class LdapticActiveModelTest < Test::Unit::TestCase
+  include ActiveModel::Lint::Tests
+
+  class Mock < Ldaptic::Class(:adapter => :mock)
+  end
+
+  def setup
+    @model = Mock::Person.new
+  end
+
+  def test_changes
+    @model.description = 'Bar'
+    assert_equal ['Bar'], @model.changes['description']
+  end
+
+  def test_errors
+    assert @model.invalid?
+    assert_equal ['Common name is mandatory'], @model.errors.full_messages
+    @model.cn = 'Douglas'
+    @model.age = 'forty two'
+    assert @model.invalid?
+    assert_equal ['Age must be an integer'], @model.errors.full_messages
+    @model.age = 42
+    assert @model.valid?
+    @model[:userPassword] = 'lol'
+    assert @model.invalid?
+    assert_equal ['User password is forbidden'], @model.errors.full_messages
+  end
+
+  def test_before_type_cast
+    @model.description = ''
+    assert_equal [], @model.description_before_type_cast
+  end
+
+end

data/test/ldaptic_adapters_test.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(File.expand_path(__FILE__)),'test_helper')
+require 'ldaptic/adapters'
+require 'ldaptic/adapters/net_ldap_adapter'
+require 'ldaptic/adapters/ldap_conn_adapter'
+
+class LdapticAdaptersTest < Test::Unit::TestCase
+  def setup
+    @ldap_conn = Ldaptic::Adapters::LDAPConnAdapter.allocate
+    @net_ldap  = Ldaptic::Adapters::NetLDAPAdapter.allocate
+  end
+
+  def test_should_parameterize_search_options
+    assert_equal(
+      ["DC=org", 0, "(objectClass=*)", nil, false, 1, 10_000, "", nil],
+      @ldap_conn.instance_eval { search_parameters(
+        :base => "DC=org",
+        :scope => 0,
+        :filter => "(objectClass=*)",
+        :attributes_only => false,
+        :timeout => 1.01
+      )}
+    )
+  end
+
+  def test_should_recapitalize
+    assert_equal "objectClass", @net_ldap.instance_eval { recapitalize("objectclass") }
+  end
+
+  def test_should_reject_invalid_adapter_options
+    assert_raise(ArgumentError) { Ldaptic::Adapters.for(:adapter => "fake") }
+    assert_raise(TypeError)     { Ldaptic::Adapters.for(Object.new) }
+    assert_not_nil Ldaptic::Adapters.for(@ldap_conn)
+  end
+
+end

data/test/ldaptic_attribute_set_test.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(File.expand_path(__FILE__)),'test_helper')
+require 'ldaptic'
+require File.join(File.dirname(File.expand_path(__FILE__)),'/mock_adapter')
+
+class LdapticAttributeSetTest < Test::Unit::TestCase
+  class Mock < Ldaptic::Class(:adapter => :mock)
+  end
+
+  def setup
+    @person = Mock::Person.new(:dn => "CN=Matz,DC=org", :description => "Foo")
+    @description = @person.description
+  end
+
+  def test_should_replace_description
+    assert_same @description, @description.replace("bar", "baz")
+    assert_equal ["bar", "baz"], @description
+  end
+
+  def test_should_add_to_description
+    assert_same @description, @description.add("bar")
+    assert_equal %w(Foo bar), @description
+    assert_same @description, @description << "baz"
+    assert_equal %w(Foo bar baz), @description
+  end
+
+  def test_should_delete_from_description
+    assert_equal "Foo", @description.delete("fOO")
+    assert_same @description, @description.delete("a", "b", "c")
+  end
+
+  def test_should_act_like_array
+    assert_equal ["Foo"], @description
+    @description.map! { |x| x.downcase }
+    assert_same @description, @description.concat(["bar"])
+    assert_equal ["foo", "bar"], @description
+    assert_same @description, @description.unshift([["baz"]])
+    assert_equal ["baz", "foo", "bar"], @description
+    assert_equal "foo", @description.delete("foo")
+    assert_nil   @description.delete("foo")
+    @description.clear
+    assert_equal [], @description
+  end
+
+  def test_should_join_on_to_s
+    @description.replace("foo", "bar")
+    assert_equal "foo\nbar", @description.to_s
+  end
+
+  def test_should_add_angles_on_inspect
+    assert_equal '<["Foo"]>', @description.inspect
+  end
+
+  def test_should_humanize
+    assert_equal 'Description', @description.human_name
+  end
+
+end

data/test/ldaptic_dn_test.rb

@@ -0,0 +1,110 @@
+$:.unshift(File.join(File.dirname(__FILE__),'..','lib')).uniq!
+require 'ldaptic/dn'
+require 'test/unit'
+
+class LdapticDNTest < Test::Unit::TestCase
+
+  class FakeSearch
+    def search(options)
+      [options] end
+  end
+
+  class FakeSearch2
+    def search2(*args)
+      [args]
+    end
+    alias search2_ext search2
+  end
+
+  def test_constructor
+    assert_equal "dc=foo,ba=\\23#\\20,zy=x", Ldaptic::DN([{"dc"=>"foo"},{"ba"=>"## "},{"zy"=>"x"}]).downcase
+    assert_equal %w(BA=bar DC=foo), Ldaptic::DN([{:dc=>"foo",:ba=>"bar"}]).split('+').sort
+    assert_equal "DC=pragprog,DC=com", Ldaptic::DN("pragprog.com")
+    assert_equal "DC=com", Ldaptic::DN(:dc=>"com")
+    assert_equal nil, Ldaptic::DN(nil)
+  end
+
+  def test_rdns
+    assert_equal [{:dc=>"pragprog"},{:dc=>"com"}], Ldaptic::DN("dc=pragprog,dc=com").rdns
+    assert_equal [{:a=>",",:b=>"+"},{:c=>"\\"}], Ldaptic::DN("a=\\,+b=\\+,c=\\\\").rdns
+    assert_equal [{:a=>" #"}], Ldaptic::DN("a=\\20\\#").rdns
+    assert_equal [{:a=>"bcdefg"}], Ldaptic::DN("a=#626364656667").rdns
+    assert  Ldaptic::DN("DC=foo").include?(:dc=>"Foo")
+    assert !Ldaptic::DN("dc=foo").include?(:dc=>"Bar")
+  end
+
+  def test_parent
+    assert_equal Ldaptic::DN("dc=com"), Ldaptic::DN("dc=pragprog,dc=com").parent
+    assert_instance_of Ldaptic::RDN, Ldaptic::DN("dc=pragprog,dc=com").rdn
+  end
+
+  def test_children
+    assert_equal Ldaptic::DN("dc=pragprog,dc=com"), Ldaptic::DN("dc=com")/"dc=pragprog"
+    assert_equal Ldaptic::DN("DC=pragprog,DC=com"), Ldaptic::DN([:dc=>"com"])/{:dc=>"pragprog"}
+    assert_equal Ldaptic::DN("DC=pragprog,DC=com"), Ldaptic::DN([:dc=>"com"])[:dc=>"pragprog"]
+    dn = Ldaptic::DN("DC=com")
+    dn << {:dc=>"pragprog"}
+    assert_equal Ldaptic::DN("DC=pragprog,DC=com"), dn
+  end
+
+  def test_equality
+    assert_equal Ldaptic::DN("dc=foo"), Ldaptic::DN("DC=foo")
+    assert_equal Ldaptic::RDN(:dc => "com"), Ldaptic::RDN('DC' => 'COM')
+    assert Ldaptic::RDN(:dc => "com") != {Object.new => true}
+    assert Ldaptic::RDN(:dc => "com") != 42
+  end
+
+  def test_still_acts_like_a_string
+    dn = Ldaptic::DN("a=b")
+    assert_equal ?a, dn[0]
+    assert_equal dn, "a=b"
+    assert_kind_of String, Array(dn).first
+    assert_raise(NoMethodError) { dn.unknown_method }
+    assert dn.include?("=")
+    assert_equal "a=bc", (Ldaptic::DN("a=b") << "c")
+  end
+
+  def test_should_search
+    dn = Ldaptic::DN("a=b", FakeSearch.new)
+    assert_equal "a=b", dn.find[:base]
+    dn = Ldaptic::DN(dn, FakeSearch2.new)
+    assert_equal "a=b", dn.find.first
+  end
+
+  def test_rdn
+    rdn = Ldaptic::RDN.new("street=Main+cn=Doe, John")
+    assert_kind_of Ldaptic::RDN, rdn.dup
+    assert_kind_of Ldaptic::RDN, rdn.clone
+    assert_equal "CN=Doe\\2C John+STREET=Main", rdn.to_str
+    assert_equal "MAIN", rdn.upcase.street
+    assert_equal "Main", rdn["Street"]
+    rdn.downcase!
+    assert_equal "main", rdn.street
+    assert_equal "main", rdn.delete(:Street)
+    assert_equal "CN=doe\\2C john+STREET=Main", rdn.merge(:street=>"Main").to_str
+  end
+
+  def test_rdn_lookup
+    rdn = Ldaptic::RDN.new(:street=>"Main", :cn=>"Doe, John")
+    assert_equal "OU=Corporate,CN=Doe\\2C John+STREET=Main", rdn[:ou=>"Corporate"].to_str
+    assert rdn.has_key?(:street)
+    assert rdn.include?('Street')
+    assert_equal "CN=", rdn[(0..2)]
+    assert_equal ["Main", "Doe, John"], rdn.values_at(:street, 'CN')
+    error_class = {}.fetch(1) rescue $!.class
+    assert_raise(error_class) { rdn.fetch(:uid) }
+    assert_nothing_raised     { rdn.fetch("STREET") }
+  end
+
+  def test_rdn_as_key
+    hash = {}
+    hash[Ldaptic::RDN(:cn => "Doe, John")] = true
+    assert hash[Ldaptic::RDN("Cn=doe\\, john")]
+  end
+
+  def test_rdn_should_raise_type_error
+    assert_raise(TypeError) { Ldaptic::RDN(Object.new) }
+    assert_raise(TypeError) { Ldaptic::RDN(Object.new => "whee") }
+  end
+
+end

data/test/ldaptic_entry_test.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(File.expand_path(__FILE__)),'test_helper')
+require 'ldaptic'
+
+class LdapticEntryTest < Test::Unit::TestCase
+
+  class Entry < Ldaptic::Entry
+    def self.namespace
+      Namespace.new
+    end
+  end
+
+  class Namespace
+    def attribute_type(attr)
+    end
+  end
+
+  def test_human_attribute_name
+    assert_equal 'Given name', Entry.human_attribute_name(:givenName)
+    assert_equal 'User PKCS12', Entry.human_attribute_name(:userPKCS12)
+  end
+
+end

data/test/ldaptic_errors_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(File.expand_path(__FILE__)),'test_helper')
+require 'ldaptic/errors'
+
+class LdapticErrorsTest < Test::Unit::TestCase
+
+  NO_SUCH_OBJECT = 32
+
+  def test_should_not_raise_on_zero
+    assert_nothing_raised { Ldaptic::Errors.raise_unless_zero(0, "success") }
+  end
+
+  def test_should_raise_no_such_object
+    assert_raise(Ldaptic::Errors::NoSuchObject) { Ldaptic::Errors.raise_unless_zero(32, "no such object") }
+  end
+
+  def test_should_have_proper_error
+    exception = Ldaptic::Errors.raise_unless_zero(1, "some error") rescue $!
+    assert_equal 1, exception.code
+    assert_equal "some error", exception.message
+    assert_match(/^#{Regexp.escape(__FILE__)}/, exception.backtrace.first)
+  end
+
+end

data/test/ldaptic_escape_test.rb

@@ -0,0 +1,47 @@
+$:.unshift(File.join(File.dirname(__FILE__),'..','lib')).uniq!
+require 'ldaptic/escape'
+require 'test/unit'
+
+class LdapticEscapeTest < Test::Unit::TestCase
+
+  PAIRS = [
+    ["\\28Hello\\5C\\2Aworld!\\29", "(Hello\\*world!)"],
+    ["\\23Good-bye\\2C world\\20", "#Good-bye, world "]
+  ]
+
+  def test_encode
+    assert_equal "FALSE", Ldaptic.encode(false)
+    assert_equal "20000101123456.000000Z", Ldaptic.encode(Time.utc(2000,1,1,12,34,56))
+    assert_equal "foo-bar", Ldaptic.encode(:foo_bar)
+  end
+
+  def test_escape
+    PAIRS.each do |escaped, unescaped|
+      assert_equal escaped, Ldaptic.escape(unescaped)
+    end
+    assert_equal "a*b\\2Ac\\00", Ldaptic.escape("a*b**c\0", true)
+    assert_equal "TRUE", Ldaptic.escape(true)
+    assert_equal "foo-bar", Ldaptic.escape(:foo_bar)
+  end
+
+  def test_should_not_mutate
+    x = ","
+    assert_equal "\\2C", Ldaptic.escape(x).upcase
+    assert_equal ",", x
+  end
+
+  def test_unescape
+    PAIRS.each do |escaped, unescaped|
+      assert_equal unescaped, Ldaptic.unescape(escaped)
+    end
+    assert_equal " whitespace!", Ldaptic.unescape("  \\20whitespace\\!  ")
+    assert_equal "abcde", Ldaptic.unescape("#6162636465")
+  end
+
+  def test_split
+    assert_equal ["a","b"],     Ldaptic.split("a*b", '*')
+    assert_equal ["a\\*b"],     Ldaptic.split("a\\*b", '*')
+    assert_equal ["a\\\\","b"], Ldaptic.split("a\\\\*b", ?*)
+  end
+
+end

data/test/ldaptic_filter_test.rb

@@ -0,0 +1,53 @@
+$:.unshift(File.join(File.dirname(__FILE__),'..','lib')).uniq!
+require 'ldaptic/filter'
+require 'test/unit'
+
+class LdapticFilterTest < Test::Unit::TestCase
+
+  def assert_ldap_filter(string, filter)
+    assert_equal string.downcase, Ldaptic::Filter(filter).process.downcase
+  end
+
+  def test_filter_from_hash
+    assert_equal nil, Ldaptic::Filter({}).process
+    assert_ldap_filter "(x-y=*)", :x_y
+    assert_ldap_filter "(x=1)", :x => 1
+    assert_ldap_filter "(x=*)", :x => true
+    assert_ldap_filter "(!(x=1))", :x! => 1
+    assert_ldap_filter "(!(x=*))", :x => false
+    assert_ldap_filter "(|(x=1)(x=2))", :x => [1, 2]
+    assert_ldap_filter "(&(x>=1)(x<=2))", :x => (1..2)
+    assert_ldap_filter "(&(x=1)(y=2))", :x => 1, :y => 2
+    assert_ldap_filter "(&(x>=1)(!(x>=2)))", :x => (1...2)
+  end
+
+  def test_filter_from_array
+    assert_ldap_filter "(sn=Sm*)", ["(sn=?*)", "Sm"]
+    assert_ldap_filter "(sn=\\2a)", ["(sn=?)", "*"]
+  end
+
+  def test_filter_from_lambda
+    assert_ldap_filter "(x=1)", lambda { |ldap| ldap.x == 1 }
+    assert_ldap_filter "(&(x>=1)(cn=*))", lambda { (x >= 1) & cn }
+  end
+
+  def test_escape_asterisks
+    assert_ldap_filter "(x=\\2a)", :x => "*"
+    assert_ldap_filter "(x=*)", :x => "*", :* => true
+  end
+
+  def test_boolean_logic
+    assert_ldap_filter "(&(a=1)(b=2))", Ldaptic::Filter(:a => 1) & {:b => 2}
+    assert_ldap_filter "(|(a=1)(b=2))", Ldaptic::Filter(:a => 1) | "(b=2)"
+    assert_ldap_filter "(!(a=1))",     ~Ldaptic::Filter(:a => 1)
+  end
+
+  def test_conversions
+    assert_equal "(a=1)", {:a => 1}.to_ldap_filter.to_s
+  end
+
+  def test_errors
+    assert_raise(TypeError) { Ldaptic::Filter(Object.new) }
+  end
+
+end

data/test/ldaptic_hierarchy_test.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(File.expand_path(__FILE__)),'test_helper')
+require 'ldaptic'
+require File.join(File.dirname(File.expand_path(__FILE__)),'/mock_adapter')
+
+class LdapticHierarchyTest < Test::Unit::TestCase
+  class Mock < Ldaptic::Class(:adapter => :mock)
+  end
+
+  def test_inheritance
+    assert defined? Mock::Top
+    assert_raise(NoMethodError) { Mock.new }
+    assert_equal Mock::Top, Mock::Person.superclass
+    assert Mock::Person.method_defined?(:sn)
+    assert !Mock::Top.method_defined?(:sn)
+    assert_equal [], Mock::Top.aux
+    assert_equal %w(simpleSecurityObject), Mock::Person.aux
+  end
+
+  def test_new
+    person = Mock::Person.new(:dn => "CN=Matz,DC=org")
+    assert !person.persisted?
+    assert_equal "Matz", person.cn
+    person.sn = "Matsumoto"
+    assert_equal "Matsumoto", person.sn
+    assert_equal %w"Matsumoto", person[:sn]
+    assert_equal %w"Matsumoto", person['sn']
+    assert_equal Ldaptic::DN("cn=Matz,dc=org"), person.dn
+    assert_equal "CN=Matz", person.rdn
+    inspect = person.inspect
+    assert_raise(TypeError) { person.distinguishedName = "Why" }
+    assert_raise(NoMethodError) { person.fakeAttribute = 42 }
+    assert inspect.include?("Mock::Person CN=Matz,DC=org")
+    assert_match(/sn: .*Matsumoto/, inspect)
+  end
+
+  def test_new_with_aux
+    person = Mock::Person.new(:dn => "CN=Matz,DC=org")
+    assert_raise(NoMethodError) { person.userPassword }
+    person.instance_variable_get(:@attributes)["objectClass"] |= ["simpleSecurityObject"]
+    assert_equal [Mock::Person, Mock::Top, Mock::SimpleSecurityObject], person.ldap_ancestors
+    assert_nothing_raised { person.userPassword = ["ruby"] }
+    assert_equal %w(ruby), person.userPassword
+  end
+
+  def test_attributes
+    assert_equal %w(age sn), Mock::Person.may(false).sort
+    assert_equal %w(age description distinguishedName sn), Mock::Person.may.sort
+    assert_equal %w(cn), Mock::Person.must(false).sort
+    assert_equal %w(cn objectClass), Mock::Person.must.sort
+    assert_equal %w(cn description distinguishedName objectClass), Mock::Top.attributes
+  end
+
+  def test_search
+    assert_kind_of Hash,   Mock.search(:limit => true, :instantiate => false)
+    assert_kind_of Array,  Mock.search(:limit => false)
+    assert_kind_of String, Mock.search(:attributes => :filter, :limit => false).first
+    assert_kind_of Array,  Mock.search(:attributes => :filter, :instantiate => false).first
+  end
+
+  def test_find
+    assert defined? Mock::SearchResult
+    result = Mock.find("CN=Matz,DC=org")
+    assert result.persisted?
+    assert_equal "CN=Matz,DC=org", result.dn
+    assert_equal 0, result.scope
+    result = Mock.find(["CN=Matz,DC=org", "CN=Why,DC=org"])
+    assert_equal 2, result.size
+  end
+
+  def test_children
+    matz = Mock.find("CN=Matz,DC=org")
+    assert_equal 0, (matz/{:child=>:data}).scope
+    assert_equal 0, matz[:child=>:data].scope
+    matz[:child=>:data].scope = 1
+    # Verify cache is working
+    assert_equal 1, matz[:child=>:data].scope
+    assert_equal "DC=org", matz.parent.dn
+    Mock.filter(true) do
+      Mock[:cn=>"Matz"].scope = 1
+      assert_equal 1, Mock[:cn=>"Matz"].scope
+    end
+    assert_equal 0, Mock[:cn=>"Matz"].scope
+  end
+
+  def test_schema
+    assert Mock.schema([:objectClass, :scope]).scope
+  end
+
+end
+