2007-11-21 13:47:55 +03:00
#!/usr/bin/python
2007-12-17 05:25:28 +03:00
# Simple tests for the ldb python bindings.
2007-11-21 13:47:55 +03:00
# Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
2007-12-17 05:25:28 +03:00
2008-09-20 17:06:26 +04:00
import os , sys
2007-11-21 13:47:55 +03:00
import unittest
2007-12-17 05:25:28 +03:00
# Required for the standalone LDB build
2007-11-21 13:47:55 +03:00
sys . path . append ( " build/lib.linux-i686-2.4 " )
import ldb
2008-12-21 06:36:16 +03:00
def filename ( ) :
return os . tempnam ( )
2007-11-21 13:47:55 +03:00
class NoContextTests ( unittest . TestCase ) :
2009-06-17 20:25:21 +04:00
2007-11-21 13:47:55 +03:00
def test_valid_attr_name ( self ) :
self . assertTrue ( ldb . valid_attr_name ( " foo " ) )
self . assertFalse ( ldb . valid_attr_name ( " 24foo " ) )
def test_timestring ( self ) :
self . assertEquals ( " 19700101000000.0Z " , ldb . timestring ( 0 ) )
self . assertEquals ( " 20071119191012.0Z " , ldb . timestring ( 1195499412 ) )
def test_string_to_time ( self ) :
self . assertEquals ( 0 , ldb . string_to_time ( " 19700101000000.0Z " ) )
self . assertEquals ( 1195499412 , ldb . string_to_time ( " 20071119191012.0Z " ) )
class SimpleLdb ( unittest . TestCase ) :
2009-06-17 20:25:21 +04:00
2007-11-21 13:47:55 +03:00
def test_connect ( self ) :
2008-12-21 06:36:16 +03:00
ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
def test_connect_none ( self ) :
ldb . Ldb ( )
def test_connect_later ( self ) :
x = ldb . Ldb ( )
2008-12-21 06:36:16 +03:00
x . connect ( filename ( ) )
2007-11-21 13:47:55 +03:00
2008-05-20 01:12:13 +04:00
def test_repr ( self ) :
x = ldb . Ldb ( )
self . assertTrue ( repr ( x ) . startswith ( " <ldb connection " ) )
2007-11-21 13:47:55 +03:00
def test_set_create_perms ( self ) :
x = ldb . Ldb ( )
x . set_create_perms ( 0600 )
def test_set_modules_dir ( self ) :
x = ldb . Ldb ( )
x . set_modules_dir ( " /tmp " )
2008-09-19 18:17:52 +04:00
def test_modules_none ( self ) :
x = ldb . Ldb ( )
self . assertEquals ( [ ] , x . modules ( ) )
def test_modules_tdb ( self ) :
x = ldb . Ldb ( " bar.ldb " )
self . assertEquals ( " [<ldb module ' tdb ' >] " , repr ( x . modules ( ) ) )
2007-11-21 13:47:55 +03:00
def test_search ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
self . assertEquals ( len ( l . search ( ) ) , 1 )
2008-01-11 05:25:22 +03:00
def test_search_controls ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2008-09-12 21:26:45 +04:00
self . assertEquals ( len ( l . search ( controls = [ " paged_results:0:5 " ] ) ) , 1 )
2008-01-11 05:25:22 +03:00
2007-11-21 13:47:55 +03:00
def test_search_attrs ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
self . assertEquals ( len ( l . search ( ldb . Dn ( l , " " ) , ldb . SCOPE_SUBTREE , " (dc=*) " , [ " dc " ] ) ) , 0 )
2007-12-24 04:19:41 +03:00
def test_search_string_dn ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-12-24 04:19:41 +03:00
self . assertEquals ( len ( l . search ( " " , ldb . SCOPE_SUBTREE , " (dc=*) " , [ " dc " ] ) ) , 0 )
2008-05-20 01:07:04 +04:00
def test_search_attr_string ( self ) :
l = ldb . Ldb ( " foo.tdb " )
self . assertRaises ( TypeError , l . search , attrs = " dc " )
2007-11-21 13:47:55 +03:00
def test_opaque ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
l . set_opaque ( " my_opaque " , l )
self . assertTrue ( l . get_opaque ( " my_opaque " ) is not None )
self . assertEquals ( None , l . get_opaque ( " unknown " ) )
def test_search_scope_base ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2009-06-17 22:17:56 +04:00
self . assertEquals ( len ( l . search ( ldb . Dn ( l , " dc=foo1 " ) ,
2007-11-21 13:47:55 +03:00
ldb . SCOPE_ONELEVEL ) ) , 0 )
def test_delete ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2009-06-17 22:17:56 +04:00
self . assertRaises ( ldb . LdbError , lambda : l . delete ( ldb . Dn ( l , " dc=foo2 " ) ) )
2007-11-21 13:47:55 +03:00
def test_contains ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2009-06-17 22:17:56 +04:00
self . assertFalse ( ldb . Dn ( l , " dc=foo3 " ) in l )
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
m = ldb . Message ( )
2009-06-17 22:17:56 +04:00
m . dn = ldb . Dn ( l , " dc=foo3 " )
2007-11-21 13:47:55 +03:00
m [ " b " ] = [ " a " ]
l . add ( m )
try :
2009-06-17 22:17:56 +04:00
self . assertTrue ( ldb . Dn ( l , " dc=foo3 " ) in l )
2007-11-21 13:47:55 +03:00
finally :
l . delete ( m . dn )
def test_get_config_basedn ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
self . assertEquals ( None , l . get_config_basedn ( ) )
def test_get_root_basedn ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
self . assertEquals ( None , l . get_root_basedn ( ) )
def test_get_schema_basedn ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
self . assertEquals ( None , l . get_schema_basedn ( ) )
def test_get_default_basedn ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
self . assertEquals ( None , l . get_default_basedn ( ) )
def test_add ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
m = ldb . Message ( )
2009-06-17 22:17:56 +04:00
m . dn = ldb . Dn ( l , " dc=foo4 " )
2007-11-21 13:47:55 +03:00
m [ " bla " ] = " bla "
self . assertEquals ( len ( l . search ( ) ) , 1 )
l . add ( m )
try :
self . assertEquals ( len ( l . search ( ) ) , 2 )
finally :
2009-06-17 22:17:56 +04:00
l . delete ( ldb . Dn ( l , " dc=foo4 " ) )
2007-11-21 13:47:55 +03:00
def test_add_dict ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2009-06-17 22:17:56 +04:00
m = { " dn " : ldb . Dn ( l , " dc=foo5 " ) ,
2007-11-21 13:47:55 +03:00
" bla " : " bla " }
self . assertEquals ( len ( l . search ( ) ) , 1 )
l . add ( m )
try :
self . assertEquals ( len ( l . search ( ) ) , 2 )
finally :
2009-06-17 22:17:56 +04:00
l . delete ( ldb . Dn ( l , " dc=foo5 " ) )
2007-11-21 13:47:55 +03:00
2007-12-20 01:27:34 +03:00
def test_add_dict_string_dn ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2009-06-17 22:17:56 +04:00
m = { " dn " : " dc=foo6 " , " bla " : " bla " }
2007-12-20 01:27:34 +03:00
self . assertEquals ( len ( l . search ( ) ) , 1 )
l . add ( m )
try :
self . assertEquals ( len ( l . search ( ) ) , 2 )
finally :
2009-06-17 22:17:56 +04:00
l . delete ( ldb . Dn ( l , " dc=foo6 " ) )
2007-12-20 01:27:34 +03:00
2007-11-21 13:47:55 +03:00
def test_rename ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
m = ldb . Message ( )
2009-06-17 22:17:56 +04:00
m . dn = ldb . Dn ( l , " dc=foo7 " )
2007-11-21 13:47:55 +03:00
m [ " bla " ] = " bla "
self . assertEquals ( len ( l . search ( ) ) , 1 )
l . add ( m )
try :
2009-06-17 22:17:56 +04:00
l . rename ( ldb . Dn ( l , " dc=foo7 " ) , ldb . Dn ( l , " dc=bar " ) )
2007-11-21 13:47:55 +03:00
self . assertEquals ( len ( l . search ( ) ) , 2 )
finally :
l . delete ( ldb . Dn ( l , " dc=bar " ) )
2007-12-24 04:19:41 +03:00
def test_rename_string_dns ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-12-24 04:19:41 +03:00
m = ldb . Message ( )
2009-06-17 22:17:56 +04:00
m . dn = ldb . Dn ( l , " dc=foo8 " )
2007-12-24 04:19:41 +03:00
m [ " bla " ] = " bla "
self . assertEquals ( len ( l . search ( ) ) , 1 )
l . add ( m )
2008-12-21 06:36:16 +03:00
self . assertEquals ( len ( l . search ( ) ) , 2 )
2007-12-24 04:19:41 +03:00
try :
2009-06-17 22:17:56 +04:00
l . rename ( " dc=foo8 " , " dc=bar " )
2007-12-24 04:19:41 +03:00
self . assertEquals ( len ( l . search ( ) ) , 2 )
finally :
l . delete ( ldb . Dn ( l , " dc=bar " ) )
2007-11-21 13:47:55 +03:00
def test_modify_delete ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
m = ldb . Message ( )
2008-01-11 05:25:22 +03:00
m . dn = ldb . Dn ( l , " dc=modifydelete " )
2007-11-21 13:47:55 +03:00
m [ " bla " ] = [ " 1234 " ]
l . add ( m )
rm = l . search ( m . dn ) [ 0 ]
self . assertEquals ( [ " 1234 " ] , list ( rm [ " bla " ] ) )
try :
m = ldb . Message ( )
2008-01-11 05:25:22 +03:00
m . dn = ldb . Dn ( l , " dc=modifydelete " )
2007-11-21 13:47:55 +03:00
m [ " bla " ] = ldb . MessageElement ( [ ] , ldb . CHANGETYPE_DELETE , " bla " )
l . modify ( m )
rm = l . search ( m . dn ) [ 0 ]
self . assertEquals ( 1 , len ( rm ) )
finally :
2008-01-11 05:25:22 +03:00
l . delete ( ldb . Dn ( l , " dc=modifydelete " ) )
2007-11-21 13:47:55 +03:00
def test_modify_add ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
m = ldb . Message ( )
2008-01-11 05:25:22 +03:00
m . dn = ldb . Dn ( l , " dc=add " )
2007-11-21 13:47:55 +03:00
m [ " bla " ] = [ " 1234 " ]
l . add ( m )
try :
m = ldb . Message ( )
2008-01-11 05:25:22 +03:00
m . dn = ldb . Dn ( l , " dc=add " )
2007-11-21 13:47:55 +03:00
m [ " bla " ] = ldb . MessageElement ( [ " 456 " ] , ldb . CHANGETYPE_ADD , " bla " )
l . modify ( m )
rm = l . search ( m . dn ) [ 0 ]
self . assertEquals ( 2 , len ( rm ) )
self . assertEquals ( [ " 1234 " , " 456 " ] , list ( rm [ " bla " ] ) )
finally :
2008-01-11 05:25:22 +03:00
l . delete ( ldb . Dn ( l , " dc=add " ) )
2007-11-21 13:47:55 +03:00
def test_modify_modify ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
m = ldb . Message ( )
2008-01-11 05:25:22 +03:00
m . dn = ldb . Dn ( l , " dc=modify2 " )
2007-11-21 13:47:55 +03:00
m [ " bla " ] = [ " 1234 " , " 456 " ]
l . add ( m )
try :
m = ldb . Message ( )
2008-01-11 05:25:22 +03:00
m . dn = ldb . Dn ( l , " dc=modify2 " )
2007-11-21 13:47:55 +03:00
m [ " bla " ] = ldb . MessageElement ( [ " 456 " ] , ldb . CHANGETYPE_MODIFY , " bla " )
l . modify ( m )
rm = l . search ( m . dn ) [ 0 ]
self . assertEquals ( 2 , len ( rm ) )
self . assertEquals ( [ " 1234 " ] , list ( rm [ " bla " ] ) )
finally :
2008-01-11 05:25:22 +03:00
l . delete ( ldb . Dn ( l , " dc=modify2 " ) )
2007-11-21 13:47:55 +03:00
def test_transaction_commit ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
l . transaction_start ( )
2009-06-17 22:17:56 +04:00
m = ldb . Message ( ldb . Dn ( l , " dc=foo9 " ) )
2007-11-21 13:47:55 +03:00
m [ " foo " ] = [ " bar " ]
l . add ( m )
l . transaction_commit ( )
l . delete ( m . dn )
def test_transaction_cancel ( self ) :
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
l . transaction_start ( )
2009-06-17 22:17:56 +04:00
m = ldb . Message ( ldb . Dn ( l , " dc=foo10 " ) )
2007-11-21 13:47:55 +03:00
m [ " foo " ] = [ " bar " ]
l . add ( m )
l . transaction_cancel ( )
2009-06-17 22:17:56 +04:00
self . assertEquals ( 0 , len ( l . search ( ldb . Dn ( l , " dc=foo10 " ) ) ) )
2007-11-21 13:47:55 +03:00
def test_set_debug ( self ) :
def my_report_fn ( level , text ) :
pass
2008-12-21 06:36:16 +03:00
l = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
l . set_debug ( my_report_fn )
2009-03-21 00:58:15 +03:00
def test_zero_byte_string ( self ) :
""" Testing we do not get trapped in the \0 byte in a property string. """
l = ldb . Ldb ( filename ( ) )
l . add ( {
" dn " : " dc=somedn " ,
" objectclass " : " user " ,
" cN " : " LDAPtestUSER " ,
" givenname " : " ldap " ,
" displayname " : " foo \0 bar " ,
} )
res = l . search ( expression = " (dn=dc=somedn) " )
self . assertEquals ( " foo \0 bar " , res [ 0 ] [ " displayname " ] [ 0 ] )
2007-11-21 13:47:55 +03:00
class DnTests ( unittest . TestCase ) :
2009-06-17 20:25:21 +04:00
2007-11-21 13:47:55 +03:00
def setUp ( self ) :
2008-12-21 06:36:16 +03:00
self . ldb = ldb . Ldb ( filename ( ) )
2007-11-21 13:47:55 +03:00
2008-12-21 00:21:39 +03:00
def test_eq ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo11,bar=bloe " )
y = ldb . Dn ( self . ldb , " dc=foo11,bar=bloe " )
2008-12-21 00:21:39 +03:00
self . assertEquals ( x , y )
2008-01-11 06:05:41 +03:00
2007-11-21 13:47:55 +03:00
def test_str ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo12,bar=bloe " )
self . assertEquals ( x . __str__ ( ) , " dc=foo12,bar=bloe " )
2007-11-21 13:47:55 +03:00
2008-05-20 01:07:04 +04:00
def test_repr ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo13,bla=blie " )
self . assertEquals ( x . __repr__ ( ) , " Dn( ' dc=foo13,bla=blie ' ) " )
2008-05-20 01:07:04 +04:00
2007-11-21 13:47:55 +03:00
def test_get_casefold ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo14,bar=bloe " )
self . assertEquals ( x . get_casefold ( ) , " DC=FOO14,BAR=bloe " )
2007-11-21 13:47:55 +03:00
def test_validate ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo15,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertTrue ( x . validate ( ) )
def test_parent ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo16,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertEquals ( " bar=bloe " , x . parent ( ) . __str__ ( ) )
2009-06-17 20:25:21 +04:00
def test_parent_nonexistant ( self ) :
x = ldb . Dn ( self . ldb , " @BLA " )
self . assertEquals ( None , x . parent ( ) )
2007-11-21 13:47:55 +03:00
def test_compare ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo17,bar=bloe " )
y = ldb . Dn ( self . ldb , " dc=foo17,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertEquals ( x , y )
2009-06-17 22:17:56 +04:00
z = ldb . Dn ( self . ldb , " dc=foo17,bar=blie " )
2007-11-21 13:47:55 +03:00
self . assertNotEquals ( z , y )
def test_is_valid ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo18,dc=bloe " )
2007-11-21 13:47:55 +03:00
self . assertTrue ( x . is_valid ( ) )
x = ldb . Dn ( self . ldb , " " )
# is_valid()'s return values appears to be a side effect of
# some other ldb functions. yuck.
# self.assertFalse(x.is_valid())
def test_is_special ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo19,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertFalse ( x . is_special ( ) )
x = ldb . Dn ( self . ldb , " @FOOBAR " )
self . assertTrue ( x . is_special ( ) )
def test_check_special ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo20,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertFalse ( x . check_special ( " FOOBAR " ) )
x = ldb . Dn ( self . ldb , " @FOOBAR " )
self . assertTrue ( x . check_special ( " @FOOBAR " ) )
def test_len ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo21,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertEquals ( 2 , len ( x ) )
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo21 " )
2007-11-21 13:47:55 +03:00
self . assertEquals ( 1 , len ( x ) )
def test_add_child ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo22,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertTrue ( x . add_child ( ldb . Dn ( self . ldb , " bla=bloe " ) ) )
2009-06-17 22:17:56 +04:00
self . assertEquals ( " bla=bloe,dc=foo22,bar=bloe " , x . __str__ ( ) )
2007-11-21 13:47:55 +03:00
def test_add_base ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo23,bar=bloe " )
2008-12-21 00:21:39 +03:00
base = ldb . Dn ( self . ldb , " bla=bloe " )
self . assertTrue ( x . add_base ( base ) )
2009-06-17 22:17:56 +04:00
self . assertEquals ( " dc=foo23,bar=bloe,bla=bloe " , x . __str__ ( ) )
2007-11-21 13:47:55 +03:00
def test_add ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo24 " )
2007-11-21 13:47:55 +03:00
y = ldb . Dn ( self . ldb , " bar=bla " )
2009-06-17 22:17:56 +04:00
self . assertEquals ( " dc=foo24,bar=bla " , str ( y + x ) )
2007-11-21 13:47:55 +03:00
def test_parse_ldif ( self ) :
msgs = self . ldb . parse_ldif ( " dn: foo=bar \n " )
msg = msgs . next ( )
self . assertEquals ( " foo=bar " , str ( msg [ 1 ] . dn ) )
self . assertTrue ( isinstance ( msg [ 1 ] , ldb . Message ) )
def test_parse_ldif_more ( self ) :
msgs = self . ldb . parse_ldif ( " dn: foo=bar \n \n \n dn: bar=bar " )
msg = msgs . next ( )
self . assertEquals ( " foo=bar " , str ( msg [ 1 ] . dn ) )
msg = msgs . next ( )
self . assertEquals ( " bar=bar " , str ( msg [ 1 ] . dn ) )
def test_canonical_string ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo25,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertEquals ( " /bloe/foo " , x . canonical_str ( ) )
def test_canonical_ex_string ( self ) :
2009-06-17 22:17:56 +04:00
x = ldb . Dn ( self . ldb , " dc=foo26,bar=bloe " )
2007-11-21 13:47:55 +03:00
self . assertEquals ( " /bloe \n foo " , x . canonical_ex_str ( ) )
class LdbMsgTests ( unittest . TestCase ) :
2009-06-17 20:25:21 +04:00
2007-11-21 13:47:55 +03:00
def setUp ( self ) :
self . msg = ldb . Message ( )
def test_init_dn ( self ) :
2009-06-17 22:17:56 +04:00
self . msg = ldb . Message ( ldb . Dn ( ldb . Ldb ( ) , " dc=foo27 " ) )
self . assertEquals ( " dc=foo27 " , str ( self . msg . dn ) )
2007-11-21 13:47:55 +03:00
2008-05-20 01:07:04 +04:00
def test_iter_items ( self ) :
self . assertEquals ( 0 , len ( self . msg . items ( ) ) )
2009-06-17 22:17:56 +04:00
self . msg . dn = ldb . Dn ( ldb . Ldb ( " foo.tdb " ) , " dc=foo28 " )
2008-05-20 01:07:04 +04:00
self . assertEquals ( 1 , len ( self . msg . items ( ) ) )
def test_repr ( self ) :
2009-06-17 22:17:56 +04:00
self . msg . dn = ldb . Dn ( ldb . Ldb ( " foo.tdb " ) , " dc=foo29 " )
2008-05-20 01:07:04 +04:00
self . msg [ " dc " ] = " foo "
2009-06-17 22:17:56 +04:00
self . assertEquals ( " Message( { ' dn ' : Dn( ' dc=foo29 ' ), ' dc ' : MessageElement([ ' foo ' ])}) " , repr ( self . msg ) )
2008-05-20 01:07:04 +04:00
2007-11-21 13:47:55 +03:00
def test_len ( self ) :
self . assertEquals ( 0 , len ( self . msg ) )
def test_notpresent ( self ) :
self . assertRaises ( KeyError , lambda : self . msg [ " foo " ] )
def test_del ( self ) :
del self . msg [ " foo " ]
def test_add_value ( self ) :
self . assertEquals ( 0 , len ( self . msg ) )
self . msg [ " foo " ] = [ " foo " ]
self . assertEquals ( 1 , len ( self . msg ) )
def test_add_value_multiple ( self ) :
self . assertEquals ( 0 , len ( self . msg ) )
self . msg [ " foo " ] = [ " foo " , " bla " ]
self . assertEquals ( 1 , len ( self . msg ) )
self . assertEquals ( [ " foo " , " bla " ] , list ( self . msg [ " foo " ] ) )
def test_set_value ( self ) :
self . msg [ " foo " ] = [ " fool " ]
self . assertEquals ( [ " fool " ] , list ( self . msg [ " foo " ] ) )
self . msg [ " foo " ] = [ " bar " ]
self . assertEquals ( [ " bar " ] , list ( self . msg [ " foo " ] ) )
def test_keys ( self ) :
2008-05-20 01:07:04 +04:00
self . msg . dn = ldb . Dn ( ldb . Ldb ( " foo.tdb " ) , " @BASEINFO " )
2007-11-21 13:47:55 +03:00
self . msg [ " foo " ] = [ " bla " ]
self . msg [ " bar " ] = [ " bla " ]
2008-05-20 01:07:04 +04:00
self . assertEquals ( [ " dn " , " foo " , " bar " ] , self . msg . keys ( ) )
2007-11-21 13:47:55 +03:00
def test_dn ( self ) :
2008-12-21 06:36:16 +03:00
self . msg . dn = ldb . Dn ( ldb . Ldb ( filename ( ) ) , " @BASEINFO " )
2007-11-21 13:47:55 +03:00
self . assertEquals ( " @BASEINFO " , self . msg . dn . __str__ ( ) )
2008-05-20 01:07:04 +04:00
def test_get_dn ( self ) :
self . msg . dn = ldb . Dn ( ldb . Ldb ( " foo.tdb " ) , " @BASEINFO " )
self . assertEquals ( " @BASEINFO " , self . msg . get ( " dn " ) . __str__ ( ) )
def test_get_other ( self ) :
self . msg [ " foo " ] = [ " bar " ]
self . assertEquals ( " bar " , self . msg . get ( " foo " ) [ 0 ] )
def test_get_unknown ( self ) :
2008-12-19 19:08:35 +03:00
self . assertEquals ( None , self . msg . get ( " lalalala " ) )
2008-05-20 01:07:04 +04:00
2007-11-21 13:47:55 +03:00
class MessageElementTests ( unittest . TestCase ) :
2009-06-17 20:25:21 +04:00
2007-11-21 13:47:55 +03:00
def test_cmp_element ( self ) :
x = ldb . MessageElement ( [ " foo " ] )
y = ldb . MessageElement ( [ " foo " ] )
z = ldb . MessageElement ( [ " bzr " ] )
self . assertEquals ( x , y )
self . assertNotEquals ( x , z )
def test_create_iterable ( self ) :
x = ldb . MessageElement ( [ " foo " ] )
self . assertEquals ( [ " foo " ] , list ( x ) )
2007-12-22 23:28:45 +03:00
2008-05-20 01:07:04 +04:00
def test_repr ( self ) :
x = ldb . MessageElement ( [ " foo " ] )
self . assertEquals ( " MessageElement([ ' foo ' ]) " , repr ( x ) )
x = ldb . MessageElement ( [ " foo " , " bla " ] )
2008-12-21 00:21:39 +03:00
self . assertEquals ( 2 , len ( x ) )
2008-05-20 01:07:04 +04:00
self . assertEquals ( " MessageElement([ ' foo ' , ' bla ' ]) " , repr ( x ) )
2008-01-11 02:23:33 +03:00
def test_get_item ( self ) :
x = ldb . MessageElement ( [ " foo " , " bar " ] )
self . assertEquals ( " foo " , x [ 0 ] )
self . assertEquals ( " bar " , x [ 1 ] )
2008-12-21 00:21:39 +03:00
self . assertEquals ( " bar " , x [ - 1 ] )
self . assertRaises ( IndexError , lambda : x [ 45 ] )
2008-01-11 02:23:33 +03:00
2008-01-11 03:02:58 +03:00
def test_len ( self ) :
x = ldb . MessageElement ( [ " foo " , " bar " ] )
self . assertEquals ( 2 , len ( x ) )
2008-01-11 03:55:56 +03:00
def test_eq ( self ) :
x = ldb . MessageElement ( [ " foo " , " bar " ] )
2008-12-21 00:21:39 +03:00
y = ldb . MessageElement ( [ " foo " , " bar " ] )
self . assertEquals ( y , x )
2008-01-11 03:55:56 +03:00
x = ldb . MessageElement ( [ " foo " ] )
2008-12-21 00:21:39 +03:00
self . assertNotEquals ( y , x )
y = ldb . MessageElement ( [ " foo " ] )
self . assertEquals ( y , x )
2008-01-11 03:55:56 +03:00
2008-12-19 19:08:35 +03:00
2007-12-22 23:28:45 +03:00
class ModuleTests ( unittest . TestCase ) :
2009-06-17 20:25:21 +04:00
2007-12-22 23:28:45 +03:00
def test_register_module ( self ) :
2008-09-19 18:17:52 +04:00
class ExampleModule :
name = " example "
ldb . register_module ( ExampleModule )
def test_use_module ( self ) :
ops = [ ]
class ExampleModule :
name = " bla "
def __init__ ( self , ldb , next ) :
ops . append ( " init " )
2008-09-20 17:06:26 +04:00
self . next = next
def search ( self , * args , * * kwargs ) :
return self . next . search ( * args , * * kwargs )
2008-09-19 18:17:52 +04:00
ldb . register_module ( ExampleModule )
2008-09-20 17:06:26 +04:00
if os . path . exists ( " usemodule.ldb " ) :
os . unlink ( " usemodule.ldb " )
2008-09-19 18:17:52 +04:00
l = ldb . Ldb ( " usemodule.ldb " )
2008-09-20 17:06:26 +04:00
l . add ( { " dn " : " @MODULES " , " @LIST " : " bla " } )
2008-09-19 18:17:52 +04:00
self . assertEquals ( [ ] , ops )
l = ldb . Ldb ( " usemodule.ldb " )
self . assertEquals ( [ " init " ] , ops )
2007-12-22 23:28:45 +03:00
2009-06-17 20:25:21 +04:00
2008-02-12 03:21:10 +03:00
if __name__ == ' __main__ ' :
import unittest
unittest . TestProgram ( )