self.ldb_user.newuser(self.test_user1, self.user_pass, userou=self.ou2)
self.ldb_user.newgroup("test_add_group1", groupou="OU=test_add_ou2,OU=test_add_ou1",
grouptype=samba.dsdb.GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP)
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
try:
self.ldb_user.newgroup("test_add_group1", groupou="OU=test_add_ou2,OU=test_add_ou1",
grouptype=samba.dsdb.GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP)
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
anonymous = SamDB(url=ldaphost, credentials=self.creds_tmp, lp=lp)
try:
anonymous.newuser("test_add_anonymous", self.user_pass)
- except LdbError, (num, _):
+ except LdbError as e2:
+ (num, _) = e2.args
self.assertEquals(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
url: www.samba.org"""
try:
self.ldb_user.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e3:
+ (num, _) = e3.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
url: www.samba.org"""
try:
self.ldb_user.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e4:
+ (num, _) = e4.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
displayName: test_changed"""
try:
self.ldb_user.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e5:
+ (num, _) = e5.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
url: www.samba.org"""
try:
self.ldb_user.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e6:
+ (num, _) = e6.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
url: www.samba.org"""
try:
self.ldb_user.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e7:
+ (num, _) = e7.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
url: www.samba.org"""
try:
self.ldb_user.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e8:
+ (num, _) = e8.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
url: www.samba.org"""
try:
self.ldb_user.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e9:
+ (num, _) = e9.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
adminDescription: blah blah blah"""
try:
self.ldb_user.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e10:
+ (num, _) = e10.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
#the user has no rights granted, this should fail
try:
self.ldb_user2.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e11:
+ (num, _) = e11.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
Member: CN=test_modify_user2,CN=Users,""" + self.base_dn
try:
self.ldb_user2.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e12:
+ (num, _) = e12.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
self.sd_utils.dacl_add_ace("CN=test_modify_group2,CN=Users," + self.base_dn, mod)
try:
self.ldb_user2.modify_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e13:
+ (num, _) = e13.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
"description")
try:
anonymous.modify(m)
- except LdbError, (num, _):
+ except LdbError as e14:
+ (num, _) = e14.args
self.assertEquals(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
anonymous = SamDB(url=ldaphost, credentials=self.creds_tmp, lp=lp)
try:
res = anonymous.search("", expression="(objectClass=*)", scope=SCOPE_SUBTREE)
- except LdbError, (num, _):
+ except LdbError as e15:
+ (num, _) = e15.args
self.assertEquals(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
try:
res = anonymous.search(self.base_dn, expression="(objectClass=*)", scope=SCOPE_SUBTREE)
- except LdbError, (num, _):
+ except LdbError as e16:
+ (num, _) = e16.args
self.assertEquals(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
try:
res = anonymous.search(anonymous.get_config_basedn(), expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- except LdbError, (num, _):
+ except LdbError as e17:
+ (num, _) = e17.args
self.assertEquals(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
try:
self.ldb_user3.search("OU=ou3,OU=ou2,OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_BASE)
- except LdbError, (num, _):
+ except LdbError as e18:
+ (num, _) = e18.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
else:
self.fail()
# Here delete User object should ALWAYS through exception
try:
self.ldb_user.delete(self.get_user_dn("test_delete_user1"))
- except LdbError, (num, _):
+ except LdbError as e19:
+ (num, _) = e19.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
try:
anonymous.delete(self.get_user_dn("test_anonymous"))
- except LdbError, (num, _):
+ except LdbError as e20:
+ (num, _) = e20.args
self.assertEquals(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
try:
self.ldb_user.rename("CN=%s,%s,%s" % (self.testuser1, self.ou1, self.base_dn), \
"CN=%s,%s,%s" % (self.testuser5, self.ou1, self.base_dn))
- except LdbError, (num, _):
+ except LdbError as e21:
+ (num, _) = e21.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
self.sd_utils.dacl_add_ace(ou2_dn, mod)
try:
self.ldb_user.rename(ou2_dn, ou3_dn)
- except LdbError, (num, _):
+ except LdbError as e22:
+ (num, _) = e22.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This rename operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
# Rename 'User object' having SD and CC to AU
try:
self.ldb_admin.rename(user_dn, rename_user_dn)
- except LdbError, (num, _):
+ except LdbError as e23:
+ (num, _) = e23.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
add: unicodePwd
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS2\"".encode('utf-16-le')) + """
""")
- except LdbError, (num, _):
+ except LdbError as e24:
+ (num, _) = e24.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
else:
# for some reason we get constraint violation instead of insufficient access error
add: unicodePwd
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS2\"".encode('utf-16-le')) + """
""")
- except LdbError, (num, _):
+ except LdbError as e25:
+ (num, _) = e25.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
else:
# for some reason we get constraint violation instead of insufficient access error
add: dBCSPwd
dBCSPwd: YYYYYYYYYYYYYYYY
""")
- except LdbError, (num, _):
+ except LdbError as e26:
+ (num, _) = e26.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
else:
self.fail()
add: userPassword
userPassword: thatsAcomplPASS2
""")
- except LdbError, (num, _):
+ except LdbError as e27:
+ (num, _) = e27.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
userPassword: thatsAcomplPASS2
""")
# This fails on Windows 2000 domain level with constraint violation
- except LdbError, (num, _):
+ except LdbError as e28:
+ (num, _) = e28.args
self.assertTrue(num == ERR_CONSTRAINT_VIOLATION or
num == ERR_UNWILLING_TO_PERFORM)
else:
replace: unicodePwd
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS1\"".encode('utf-16-le')) + """
""")
- except LdbError, (num, _):
+ except LdbError as e29:
+ (num, _) = e29.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
replace: userPassword
userPassword: thatsAcomplPASS1
""")
- except LdbError, (num, _):
+ except LdbError as e30:
+ (num, _) = e30.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
userPassword: thatsAcomplPASS1
""")
# This fails on Windows 2000 domain level with constraint violation
- except LdbError, (num, _):
+ except LdbError as e31:
+ (num, _) = e31.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
def test_reset_password3(self):
replace: unicodePwd
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS1\"".encode('utf-16-le')) + """
""")
- except LdbError, (num, _):
+ except LdbError as e32:
+ (num, _) = e32.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
replace: userPassword
userPassword: thatsAcomplPASS1
""")
- except LdbError, (num, _):
+ except LdbError as e33:
+ (num, _) = e33.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
userPassword: thatsAcomplPASS1
""")
# This fails on Windows 2000 domain level with constraint violation
- except LdbError, (num, _):
+ except LdbError as e34:
+ (num, _) = e34.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
class AclExtendedTests(AclTests):
try:
self.undelete_deleted(self.deleted_dn1, self.testuser1_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e35:
+ (num, _) = e35.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# seems that permissions on isDeleted and distinguishedName are irrelevant
try:
self.undelete_deleted_with_mod(self.deleted_dn3, self.testuser3_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e36:
+ (num, _) = e36.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# undelete in an ou, in which we have no right to create children
try:
self.undelete_deleted(self.deleted_dn4, self.new_dn_ou)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e37:
+ (num, _) = e37.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# delete is not required
try:
self.undelete_deleted(self.deleted_dn4, self.testuser4_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e38:
+ (num, _) = e38.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
class AclSPNTests(AclTests):
netbiosdomain = self.dcctx.get_domain_name()
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "HOST/%s/%s" % (ctx.myname, netbiosdomain))
- except LdbError, (num, _):
+ except LdbError as e39:
+ (num, _) = e39.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
mod = "(OA;;SW;f3a64788-5306-11d1-a9c5-0000f80367c1;;%s)" % str(self.user_sid1)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "ldap/%s.%s/ForestDnsZones.%s" %
(ctx.myname, ctx.dnsdomain, ctx.dnsdomain))
- except LdbError, (num, _):
+ except LdbError as e40:
+ (num, _) = e40.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "ldap/%s.%s/DomainDnsZones.%s" %
(ctx.myname, ctx.dnsdomain, ctx.dnsdomain))
- except LdbError, (num, _):
+ except LdbError as e41:
+ (num, _) = e41.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "nosuchservice/%s/%s" % ("abcd", "abcd"))
- except LdbError, (num, _):
+ except LdbError as e42:
+ (num, _) = e42.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "GC/%s.%s/%s" %
(ctx.myname, ctx.dnsdomain, netbiosdomain))
- except LdbError, (num, _):
+ except LdbError as e43:
+ (num, _) = e43.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "E3514235-4B06-11D1-AB04-00C04FC2DCD2/%s/%s" %
(ctx.ntds_guid, ctx.dnsdomain))
- except LdbError, (num, _):
+ except LdbError as e44:
+ (num, _) = e44.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
def test_computer_spn(self):
#user has neither WP nor Validated-SPN, access denied expected
try:
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s/%s" % (self.computername, netbiosdomain))
- except LdbError, (num, _):
+ except LdbError as e45:
+ (num, _) = e45.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
mod = "(OA;;SW;f3a64788-5306-11d1-a9c5-0000f80367c1;;%s)" % str(self.user_sid1)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s/%s" % (self.computername, netbiosdomain))
- except LdbError, (num, _):
+ except LdbError as e46:
+ (num, _) = e46.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s.%s/%s" %
(self.computername, self.dcctx.dnsdomain, netbiosdomain))
- except LdbError, (num, _):
+ except LdbError as e47:
+ (num, _) = e47.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s/%s" %
(self.computername, self.dcctx.dnsdomain))
- except LdbError, (num, _):
+ except LdbError as e48:
+ (num, _) = e48.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s.%s/%s" %
(self.computername, self.dcctx.dnsdomain, self.dcctx.dnsdomain))
- except LdbError, (num, _):
+ except LdbError as e49:
+ (num, _) = e49.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "GC/%s.%s/%s" %
(self.computername, self.dcctx.dnsdomain, self.dcctx.dnsforest))
- except LdbError, (num, _):
+ except LdbError as e50:
+ (num, _) = e50.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "ldap/%s/%s" % (self.computername, netbiosdomain))
- except LdbError, (num, _):
+ except LdbError as e51:
+ (num, _) = e51.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "ldap/%s.%s/ForestDnsZones.%s" %
(self.computername, self.dcctx.dnsdomain, self.dcctx.dnsdomain))
- except LdbError, (num, _):
+ except LdbError as e52:
+ (num, _) = e52.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
def test_spn_rwdc(self):
self.ldb.search(dn,
scope=SCOPE_BASE,
attrs=['cn'])
- except LdbError as (num, msg):
+ except LdbError as e:
+ (num, msg) = e.args
if num != 32:
raise
try:
ldb.delete(dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
def test_delete_protection(self):
try:
self.ldb.delete("cn=ldaptestcontainer," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
self.ldb.delete("cn=ldaptestcontainer," + self.base_dn, ["tree_delete:1"])
res = self.ldb.search("cn=ldaptestcontainer," + self.base_dn,
scope=SCOPE_BASE, attrs=[])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e2:
+ (num, _) = e2.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
try:
res = self.ldb.search("cn=entry1,cn=ldaptestcontainer," + self.base_dn,
scope=SCOPE_BASE, attrs=[])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e3:
+ (num, _) = e3.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
try:
res = self.ldb.search("cn=entry2,cn=ldaptestcontainer," + self.base_dn,
scope=SCOPE_BASE, attrs=[])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e4:
+ (num, _) = e4.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
delete_force(self.ldb, "cn=entry1,cn=ldaptestcontainer," + self.base_dn)
try:
self.ldb.delete(res[0]["dsServiceName"][0])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e5:
+ (num, _) = e5.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
res = self.ldb.search(self.base_dn, attrs=["rIDSetReferences"],
try:
self.ldb.delete(res[0]["rIDSetReferences"][0])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e6:
+ (num, _) = e6.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.delete(res[0]["rIDSetReferences"][0], ["tree_delete:1"])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e7:
+ (num, _) = e7.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Deletes failing since three main crossRef objects are protected
try:
self.ldb.delete("cn=Enterprise Schema,cn=Partitions," + self.configuration_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e8:
+ (num, _) = e8.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.delete("cn=Enterprise Schema,cn=Partitions," + self.configuration_dn, ["tree_delete:1"])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e9:
+ (num, _) = e9.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.delete("cn=Enterprise Configuration,cn=Partitions," + self.configuration_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e10:
+ (num, _) = e10.args
self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
try:
self.ldb.delete("cn=Enterprise Configuration,cn=Partitions," + self.configuration_dn, ["tree_delete:1"])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e11:
+ (num, _) = e11.args
self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
res = self.ldb.search("cn=Partitions," + self.configuration_dn, attrs=[],
try:
self.ldb.delete(res[0].dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e12:
+ (num, _) = e12.args
self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
try:
self.ldb.delete(res[0].dn, ["tree_delete:1"])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e13:
+ (num, _) = e13.args
self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
# Delete failing since "SYSTEM_FLAG_DISALLOW_DELETE"
try:
self.ldb.delete("CN=Users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e14:
+ (num, _) = e14.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Tree-delete failing since "isCriticalSystemObject"
try:
self.ldb.delete("CN=Computers," + self.base_dn, ["tree_delete:1"])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e15:
+ (num, _) = e15.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
def test_all(self):
attr_dn_new = attr_dn.replace(attr_name, attr_name + "-NEW")
try:
self.sam_db.rename(attr_dn, attr_dn_new)
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.fail("failed to change CN for %s: %s" % (attr_name, _))
# compare resulting schemaInfo
class_dn_new = class_dn.replace(class_name, class_name + "-NEW")
try:
self.sam_db.rename(class_dn, class_dn_new)
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.fail("failed to change CN for %s: %s" % (class_name, _))
# compare resulting schemaInfo
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectClass": [] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# Invalid objectclass specified
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectClass": "X" })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e2:
+ (num, _) = e2.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
# Invalid objectCategory specified
"objectClass": "person",
"objectCategory": self.base_dn })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e3:
+ (num, _) = e3.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# Multi-valued "systemFlags"
"objectClass": "person",
"systemFlags": ["0", str(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE)] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e4:
+ (num, _) = e4.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# We cannot instanciate from an abstract object class ("connectionPoint"
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectClass": "connectionPoint" })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e5:
+ (num, _) = e5.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.add({
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectClass": ["person", "leaf"] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e6:
+ (num, _) = e6.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# Objects instanciated using "satisfied" abstract classes (concrete
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectClass": ["person", "container"] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e7:
+ (num, _) = e7.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# Test allowed system flags
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e8:
+ (num, _) = e8.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# We cannot delete classes which weren't specified
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e9:
+ (num, _) = e9.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
# An invalid class cannot be added
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e10:
+ (num, _) = e10.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
# We cannot add a the new top-most structural class "user" here since
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e11:
+ (num, _) = e11.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# An already specified objectclass cannot be added another time
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e12:
+ (num, _) = e12.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
# Auxiliary classes can always be added
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e13:
+ (num, _) = e13.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# Objectclass replace operations can be performed as well
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e14:
+ (num, _) = e14.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# More than one change operation is allowed
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e15:
+ (num, _) = e15.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e16:
+ (num, _) = e16.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# Classes can be removed unless attributes of them are used.
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e17:
+ (num, _) = e17.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# Remove the previously specified attribute
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e18:
+ (num, _) = e18.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# Add a new top-most structural class "inetOrgPerson" and remove it
"dn": "cn=ldaptestobject," + self.base_dn,
"objectclass": "configuration"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e19:
+ (num, _) = e19.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
"dn": "cn=Test Secret,cn=system," + self.base_dn,
"objectclass": "secret"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e20:
+ (num, _) = e20.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e21:
+ (num, _) = e21.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=Test Secret,cn=system," + self.base_dn)
"objectclass": "container",
"isCriticalSystemObject": "TRUE"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e22:
+ (num, _) = e22.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
self.ldb.add({
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e23:
+ (num, _) = e23.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
+ self.base_dn,
"objectclass": "group"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e24:
+ (num, _) = e24.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
delete_force(self.ldb, "cn=ldaptestgroup,cn=thisdoesnotexist123,"
"dn": "ou=testou,cn=users," + self.base_dn,
"objectclass": "organizationalUnit"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e25:
+ (num, _) = e25.args
self.assertEquals(num, ERR_NAMING_VIOLATION)
delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
"objectclass": "group",
"thisdoesnotexist": "x"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e26:
+ (num, _) = e26.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
self.ldb.add({
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e27:
+ (num, _) = e27.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
"dn": "cn=ldaptestobject," + self.base_dn,
"objectclass": "ipProtocol"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e28:
+ (num, _) = e28.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# inadequate but schema-valid attribute specified
"ipProtocolNumber": "1",
"uid" : "0"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e29:
+ (num, _) = e29.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
self.ldb.add({
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e30:
+ (num, _) = e30.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# mandatory attribute delete trial
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e31:
+ (num, _) = e31.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# mandatory attribute delete trial
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e32:
+ (num, _) = e32.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
"objectclass": "group",
"sAMAccountName": ["nam1", "nam2"]})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e33:
+ (num, _) = e33.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.ldb.add({
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e34:
+ (num, _) = e34.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e35:
+ (num, _) = e35.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
"managedBy": managers
})
self.fail("failed to fail to add multiple managedBy attributes")
- except LdbError as (num, _):
+ except LdbError as e36:
+ (num, _) = e36.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
managee = "cn=group2," + ou
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e37:
+ (num, _) = e37.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e38:
+ (num, _) = e38.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
self.ldb.delete(ou, ['tree_delete:1'])
"objectClass": "person",
"sn": "" })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e39:
+ (num, _) = e39.args
self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
# Too long (max. 64)
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e40:
+ (num, _) = e40.args
self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
# Too long (max. 64)
try:
ldb.add(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e41:
+ (num, _) = e41.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e42:
+ (num, _) = e42.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
try:
ldb.add(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e43:
+ (num, _) = e43.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.ldb.add({
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e44:
+ (num, _) = e44.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e45:
+ (num, _) = e45.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
"objectclass": "group",
"instanceType": ["0", "1"]})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e46:
+ (num, _) = e46.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# The head NC flag cannot be set without the write flag
"objectclass": "group",
"instanceType": "1" })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e47:
+ (num, _) = e47.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# We cannot manipulate NCs without the head NC flag
"objectclass": "group",
"instanceType": "32" })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e48:
+ (num, _) = e48.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
self.ldb.add({
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e49:
+ (num, _) = e49.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e50:
+ (num, _) = e50.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e51:
+ (num, _) = e51.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
"objectclass": "user",
"instanceType": "3" })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e52:
+ (num, _) = e52.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
try:
ldb.add(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e53:
+ (num, _) = e53.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
# a wrong "distinguishedName" attribute is obviously tolerated
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e54:
+ (num, _) = e54.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e55:
+ (num, _) = e55.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e56:
+ (num, _) = e56.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e57:
+ (num, _) = e57.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
try:
self.ldb.search("=,cn=users," + self.base_dn, scope=SCOPE_BASE)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e58:
+ (num, _) = e58.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# empty RDN name
try:
self.ldb.search("cn=,cn=users," + self.base_dn, scope=SCOPE_BASE)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e59:
+ (num, _) = e59.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
try:
self.ldb.search("=ldaptestgroup,cn=users," + self.base_dn, scope=SCOPE_BASE)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e60:
+ (num, _) = e60.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# Add
"dn": "=,cn=users," + self.base_dn,
"objectclass": "group"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e61:
+ (num, _) = e61.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# empty RDN name
"dn": "=ldaptestgroup,cn=users," + self.base_dn,
"objectclass": "group"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e62:
+ (num, _) = e62.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# empty RDN value
"dn": "cn=,cn=users," + self.base_dn,
"objectclass": "group"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e63:
+ (num, _) = e63.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# a wrong RDN candidate
"dn": "description=xyz,cn=users," + self.base_dn,
"objectclass": "group"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e64:
+ (num, _) = e64.args
self.assertEquals(num, ERR_NAMING_VIOLATION)
delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e65:
+ (num, _) = e65.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# Delete
try:
self.ldb.delete("cn=,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e66:
+ (num, _) = e66.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# Rename
self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
"=,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e67:
+ (num, _) = e67.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# new empty RDN name
self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
"=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e68:
+ (num, _) = e68.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# new empty RDN value
self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
"cn=,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e69:
+ (num, _) = e69.args
self.assertEquals(num, ERR_NAMING_VIOLATION)
# new wrong RDN candidate
self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
"description=xyz,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e70:
+ (num, _) = e70.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
self.ldb.rename("cn=,cn=users," + self.base_dn,
"cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e71:
+ (num, _) = e71.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
# names
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e72:
+ (num, _) = e72.args
self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e73:
+ (num, _) = e73.args
self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
"""
self.ldb.add_ldif(ldif)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e74:
+ (num, _) = e74.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
# cannot rename to be a child of itself
ldb.rename(self.base_dn, "dc=test," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e75:
+ (num, _) = e75.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
# inexistent object
ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e76:
+ (num, _) = e76.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
self.ldb.add({
# containment problem: a user entry cannot contain user entries
ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser4,cn=ldaptestuser3,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e77:
+ (num, _) = e77.args
self.assertEquals(num, ERR_NAMING_VIOLATION)
try:
# invalid parent
ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=people,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e78:
+ (num, _) = e78.args
self.assertEquals(num, ERR_OTHER)
try:
# invalid target DN syntax
ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, ",cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e79:
+ (num, _) = e79.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
try:
# invalid RDN name
ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "ou=ldaptestuser3,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e80:
+ (num, _) = e80.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
try:
ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers,CN=Services," + self.configuration_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e81:
+ (num, _) = e81.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Limited move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE"
try:
ldb.rename("CN=Directory Service,CN=Windows NT,CN=Services," + self.configuration_dn, "CN=Directory Service,CN=RRAS,CN=Services," + self.configuration_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e82:
+ (num, _) = e82.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Rename failing since no "SYSTEM_FLAG_CONFIG_ALLOW_RENAME"
try:
ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers2," + self.configuration_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e83:
+ (num, _) = e83.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# It's not really possible to test moves on the schema partition since
try:
ldb.rename("CN=Top," + self.schema_dn, "CN=Top2," + self.schema_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e84:
+ (num, _) = e84.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Move failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE"
try:
ldb.rename("CN=Users," + self.base_dn, "CN=Users,CN=Computers," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e85:
+ (num, _) = e85.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Rename failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME"
try:
ldb.rename("CN=Users," + self.base_dn, "CN=Users2," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e86:
+ (num, _) = e86.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Performs some other constraints testing
try:
ldb.rename("CN=Policies,CN=System," + self.base_dn, "CN=Users2," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e87:
+ (num, _) = e87.args
self.assertEquals(num, ERR_OTHER)
def test_rename_twice(self):
objectGUID: bd3480c9-58af-4cd8-92df-bc4a18b6e44d
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e88:
+ (num, _) = e88.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
self.ldb.add({
objectGUID: bd3480c9-58af-4cd8-92df-bc4a18b6e44d
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e89:
+ (num, _) = e89.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectclass": "user",
"memberOf": "cn=ldaptestgroup,cn=users," + self.base_dn})
- except LdbError, (num, _):
+ except LdbError as e90:
+ (num, _) = e90.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
ldb.add({
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e91:
+ (num, _) = e91.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e92:
+ (num, _) = e92.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e93:
+ (num, _) = e93.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
"cn": "LDAPtest2COMPUTER"
})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e94:
+ (num, _) = e94.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
try:
"sAMAccountType": str(ATYPE_NORMAL_ACCOUNT)
})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e95:
+ (num, _) = e95.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
servicePrincipalName: cifs/ldaptest2computer
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e96:
+ (num, msg) = e96.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
ldb.modify_ldif("""
servicePrincipalName: host/ldaptest2computer
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e97:
+ (num, msg) = e97.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
# Testing ranged results
"objectClass": "user",
"cn": "LDAPtestUSER3"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e98:
+ (num, _) = e98.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# rename back
ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn,
"cn=ldaptestuser2,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e99:
+ (num, _) = e99.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
# ensure can now use that name
try:
ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e100:
+ (num, _) = e100.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
try:
ldb.rename("cn=ldaptestuser3,cn=users,%s" % self.base_dn, "cn=ldaptestuser3,%s" % ldb.get_config_basedn())
self.fail()
- except LdbError, (num, _):
+ except LdbError as e101:
+ (num, _) = e101.args
self.assertTrue(num in (71, 64))
ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser5,cn=users," + self.base_dn)
expression="(&(cn=ldaptestuser4)(objectClass=user))",
scope=SCOPE_SUBTREE)
self.fail(res)
- except LdbError, (num, _):
+ except LdbError as e102:
+ (num, _) = e102.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
# Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e103:
+ (num, _) = e103.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
# Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
try:
ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e104:
+ (num, _) = e104.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn
try:
ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e105:
+ (num, _) = e105.args
self.assertTrue(num in (ERR_UNWILLING_TO_PERFORM, ERR_OTHER))
# Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn
try:
ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e106:
+ (num, _) = e106.args
self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
# Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
"sAMAccountName": user_name,
"nTSecurityDescriptor": [] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e107:
+ (num, _) = e107.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
finally:
delete_force(self.ldb, user_dn)
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e108:
+ (num, _) = e108.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e109:
+ (num, _) = e109.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e110:
+ (num, _) = e110.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, user_dn)
try:
self.ldb.set_dsheuristics(dshstr + "x")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
dshstr = dshstr + str(i)
else:
try:
self.ldb.add_ldif(ldif)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
ldif = """
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add duplicate attributeID value")
- except LdbError, (enum, estr):
+ except LdbError as e2:
+ (enum, estr) = e2.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add duplicate governsID conflicting with attributeID value")
- except LdbError, (enum, estr):
+ except LdbError as e3:
+ (enum, estr) = e3.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add attribute with duplicate CN")
- except LdbError, (enum, estr):
+ except LdbError as e4:
+ (enum, estr) = e4.args
self.assertEquals(enum, ERR_ENTRY_ALREADY_EXISTS)
def test_duplicate_implicit_ldapdisplayname(self):
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add attribute with duplicate of the implicit ldapDisplayName")
- except LdbError, (enum, estr):
+ except LdbError as e5:
+ (enum, estr) = e5.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add attribute with duplicate ldapDisplayName")
- except LdbError, (enum, estr):
+ except LdbError as e6:
+ (enum, estr) = e6.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add class with duplicate ldapDisplayName")
- except LdbError, (enum, estr):
+ except LdbError as e7:
+ (enum, estr) = e7.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.modify_ldif(ldif)
self.fail("Should have failed to modify schema to have attribute with duplicate ldapDisplayName")
- except LdbError, (enum, estr):
+ except LdbError as e8:
+ (enum, estr) = e8.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.modify_ldif(ldif)
self.fail("Should have failed to modify schema to have attribute with duplicate attributeID")
- except LdbError, (enum, estr):
+ except LdbError as e9:
+ (enum, estr) = e9.args
self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
def test_remove_ldapdisplayname(self):
try:
self.ldb.modify_ldif(ldif)
self.fail("Should have failed to remove the ldapdisplayname")
- except LdbError, (enum, estr):
+ except LdbError as e10:
+ (enum, estr) = e10.args
self.assertEquals(enum, ERR_OBJECT_CLASS_VIOLATION)
def test_rename_ldapdisplayname(self):
try:
self.ldb.modify_ldif(ldif)
self.fail("Should have failed to modify schema to have different attributeID")
- except LdbError, (enum, estr):
+ except LdbError as e11:
+ (enum, estr) = e11.args
self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.modify_ldif(ldif)
self.fail("Should have failed to modify schema to have the same attributeID")
- except LdbError, (enum, estr):
+ except LdbError as e12:
+ (enum, estr) = e12.args
self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (enum, estr):
+ except LdbError as e13:
+ (enum, estr) = e13.args
self.fail(estr)
attr_name_2 = "test-generated-linkID-2" + time.strftime("%s", time.gmtime()) + "-" + rand
try:
self.ldb.add_ldif(ldif)
- except LdbError, (enum, estr):
+ except LdbError as e14:
+ (enum, estr) = e14.args
self.fail(estr)
res = self.ldb.search("CN=%s,%s" % (attr_name_1, self.schema_dn),
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add duplicate linkID value")
- except LdbError, (enum, estr):
+ except LdbError as e15:
+ (enum, estr) = e15.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
# If we add another attribute with the attributeID or lDAPDisplayName
try:
self.ldb.add_ldif(ldif)
- except LdbError, (enum, estr):
+ except LdbError as e16:
+ (enum, estr) = e16.args
self.fail(estr)
res = self.ldb.search("CN=%s,%s" % (attr_name_3, self.schema_dn),
try:
self.ldb.add_ldif(ldif)
- except LdbError, (enum, estr):
+ except LdbError as e17:
+ (enum, estr) = e17.args
self.fail(estr)
res = self.ldb.search("CN=%s,%s" % (attr_name_4, self.schema_dn),
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add duplicate backlink")
- except LdbError, (enum, estr):
+ except LdbError as e18:
+ (enum, estr) = e18.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
# If we try to supply the attributeID or ldapDisplayName
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add backlink of backlink")
- except LdbError, (enum, estr):
+ except LdbError as e19:
+ (enum, estr) = e19.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
attr_name = "test-generated-linkID-backlink-invalid-2" + time.strftime("%s", time.gmtime()) + "-" + rand
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add backlink of backlink")
- except LdbError, (enum, estr):
+ except LdbError as e20:
+ (enum, estr) = e20.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
def test_generated_mAPIID(self):
try:
self.ldb.add_ldif(ldif)
- except LdbError, (enum, estr):
+ except LdbError as e21:
+ (enum, estr) = e21.args
self.fail(estr)
res = self.ldb.search("CN=%s,%s" % (attr_name_1, self.schema_dn),
try:
self.ldb.add_ldif(ldif)
self.fail("Should have failed to add duplicate mAPIID value")
- except LdbError, (enum, estr):
+ except LdbError as e22:
+ (enum, estr) = e22.args
self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.modify_ldif(ldif)
self.fail("Should have failed to modify schema to have different governsID")
- except LdbError, (enum, estr):
+ except LdbError as e23:
+ (enum, estr) = e23.args
self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.modify_ldif(ldif)
self.fail("Should have failed to modify schema to have the same governsID")
- except LdbError, (enum, estr):
+ except LdbError as e24:
+ (enum, estr) = e24.args
self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.add_ldif(ldif_fail)
self.fail("Adding attribute with preset msDS-IntId should fail")
- except LdbError, (num, _):
+ except LdbError as e25:
+ (num, _) = e25.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# add the new attribute and update schema
try:
self.ldb.modify(msg)
self.fail("Modifying msDS-IntId should return error")
- except LdbError, (num, _):
+ except LdbError as e26:
+ (num, _) = e26.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# 2. Create attribute with systemFlags = FLAG_SCHEMA_BASE_OBJECT
try:
self.ldb.add_ldif(ldif_fail)
self.fail("Adding attribute with preset msDS-IntId should fail")
- except LdbError, (num, _):
+ except LdbError as e27:
+ (num, _) = e27.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# add the new attribute and update schema
try:
self.ldb.modify(msg)
self.fail("Modifying msDS-IntId should return error")
- except LdbError, (num, _):
+ except LdbError as e28:
+ (num, _) = e28.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.modify(msg)
self.fail("Modifying msDS-IntId should return error")
- except LdbError, (num, _):
+ except LdbError as e29:
+ (num, _) = e29.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# 2. Create Class with systemFlags = FLAG_SCHEMA_BASE_OBJECT
try:
self.ldb.modify(msg)
self.fail("Modifying msDS-IntId should return error")
- except LdbError, (num, _):
+ except LdbError as e30:
+ (num, _) = e30.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
res = self.ldb.search(class_dn, scope=SCOPE_BASE, attrs=["msDS-IntId"])
self.assertEquals(len(res), 1)
ntds_search_dn = "CN=NTDS Settings,%s" % ldb_msg['dn']
try:
res_check = self.ldb.search(ntds_search_dn, attrs=["objectCategory"])
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
print("Server entry %s doesn't have a NTDS settings object" % res[0]['dn'])
else:
self.dn_string_attribute, ": S:5:ABCD:" + self.base_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
# add object with the same dn but with different string value in case
self.dn_string_attribute, ": S:5:abcde:" + self.base_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different string value
self.dn_string_attribute, ": S:5:FGHIJ:" + self.base_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e2:
+ (num, _) = e2.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different dn and string value
self.dn_string_attribute, ": S:5:FGHIJ:" + self.schema_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e3:
+ (num, _) = e3.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different dn value
self.dn_string_attribute, ": S:5:ABCDE:" + self.schema_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e4:
+ (num, _) = e4.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with GUID instead of DN
self.dn_string_attribute, ": S:5:ABCDE:<GUID=%s>" % str(uuid.uuid4()))
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e5:
+ (num, _) = e5.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# add object with SID instead of DN
self.dn_string_attribute, ": S:5:ABCDE:<SID=%s>" % self.ldb.get_domain_sid())
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e6:
+ (num, _) = e6.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# add object with random string instead of DN
self.dn_string_attribute, ": S:5:ABCDE:randomSTRING")
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e7:
+ (num, _) = e7.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
def test_dn_binary(self):
self.dn_binary_attribute, ": B:5:67890:" + self.base_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e8:
+ (num, _) = e8.args
self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
# add object with the same dn but with different binary value
self.dn_binary_attribute, ": B:4:5678:" + self.base_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e9:
+ (num, _) = e9.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different binary and dn value
self.dn_binary_attribute, ": B:4:5678:" + self.schema_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e10:
+ (num, _) = e10.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different dn value
self.dn_binary_attribute, ": B:4:1234:" + self.schema_dn)
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e11:
+ (num, _) = e11.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with GUID instead of DN
self.dn_binary_attribute, ": B:4:1234:<GUID=%s>" % str(uuid.uuid4()))
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e12:
+ (num, _) = e12.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# add object with SID instead of DN
self.dn_binary_attribute, ": B:4:1234:<SID=%s>" % self.ldb.get_domain_sid())
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e13:
+ (num, _) = e13.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# add object with random string instead of DN
self.dn_binary_attribute, ": B:4:1234:randomSTRING")
try:
self.ldb.add_ldif(ldif)
- except LdbError, (num, _):
+ except LdbError as e14:
+ (num, _) = e14.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
TestProgram(module=__name__, opts=subunitopts)
"""Assert a function raises a particular LdbError."""
try:
f(*args, **kwargs)
- except ldb.LdbError as (num, msg):
+ except ldb.LdbError as e:
+ (num, msg) = e.args
if num != errcode:
lut = {v: k for k, v in vars(ldb).iteritems()
if k.startswith('ERR_') and isinstance(v, int)}
try:
res = notify1.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e10:
+ (num, _) = e10.args
self.assertEquals(num, ERR_TIME_LIMIT_EXCEEDED)
self.assertIsNotNone(msg3)
continue
res = notifies[i].result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
if num == ERR_ADMIN_LIMIT_EXCEEDED:
num_admin_limit += 1
continue
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_TIME_LIMIT_EXCEEDED)
try:
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e2:
+ (num, _) = e2.args
self.assertEquals(num, ERR_TIME_LIMIT_EXCEEDED)
try:
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e3:
+ (num, _) = e3.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e4:
+ (num, _) = e4.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e5:
+ (num, _) = e5.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e6:
+ (num, _) = e6.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e7:
+ (num, _) = e7.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e8:
+ (num, _) = e8.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
res = self.ldb.search(base=self.ldb.get_schema_basedn(),
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e9:
+ (num, _) = e9.args
if num != ERR_UNWILLING_TO_PERFORM:
print "va[%s]" % va
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
self.fail()
res = hnd.result()
self.fail()
- except LdbError, (num, _):
+ except LdbError as e11:
+ (num, _) = e11.args
if num != ERR_UNWILLING_TO_PERFORM:
print "va[%s]" % va
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e:
+ (num, msg) = e.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e1:
+ (num, msg) = e1.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e2:
+ (num, msg) = e2.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e3:
+ (num, msg) = e3.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e4:
+ (num, msg) = e4.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
userPassword: thatsAcomplPASS2x
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e5:
+ (num, msg) = e5.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
userPassword: thatsAcomplPASS2x
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e6:
+ (num, msg) = e6.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS2x\"".encode('utf-16-le')) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e7:
+ (num, msg) = e7.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
userPassword: thatsAcomplPASS2XYZ
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e8:
+ (num, msg) = e8.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
userPassword: thatsAcomplPASS2XYZ
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e9:
+ (num, msg) = e9.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS2\"".encode('utf-16-le')) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e10:
+ (num, msg) = e10.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
unicodePwd:: """ + base64.b64encode(new_utf16) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e11:
+ (num, msg) = e11.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
unicodePwd:: """ + base64.b64encode(new_utf16) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e12:
+ (num, msg) = e12.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
unicodePwd:: """ + base64.b64encode(new_utf16) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e13:
+ (num, msg) = e13.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
unicodePwd:: """ + base64.b64encode(new_utf16) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e14:
+ (num, msg) = e14.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
unicodePwd:: """ + base64.b64encode(invalid_utf16) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e15:
+ (num, msg) = e15.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
unicodePwd:: """ + base64.b64encode(new_utf16) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e16:
+ (num, msg) = e16.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
unicodePwd:: """ + base64.b64encode(new_utf16) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e17:
+ (num, msg) = e17.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
unicodePwd:: """ + base64.b64encode(new_utf16) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e18:
+ (num, msg) = e18.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e19:
+ (num, msg) = e19.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# Windows (2008 at least) seems to have some small bug here: it
# returns "0000056A" on longer (always wrong) previous passwords.
try:
ldb = SamDB(url=self.host_url, credentials=fail_creds, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e:
+ (num, msg) = e.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
try:
ldb = SamDB(url=url, credentials=creds, lp=lp)
self.fail("Login unexpectedly succeeded")
- except LdbError, (num, msg):
+ except LdbError as e1:
+ (num, msg) = e1.args
if errno is not None:
self.assertEquals(num, errno, ("Login failed in the wrong way"
"(got err %d, expected %d)" %
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e2:
+ (num, msg) = e2.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e3:
+ (num, msg) = e3.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e4:
+ (num, msg) = e4.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e5:
+ (num, msg) = e5.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e6:
+ (num, msg) = e6.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e7:
+ (num, msg) = e7.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e8:
+ (num, msg) = e8.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e9:
+ (num, msg) = e9.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e:
+ (num, msg) = e.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# Windows (2008 at least) seems to have some small bug here: it
# returns "0000056A" on longer (always wrong) previous passwords.
add: userPassword
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# Enables the user account
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e2:
+ (num, _) = e2.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
def test_unicodePwd_hash_change(self):
unicodePwd: YYYYYYYYYYYYYYYY
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e3:
+ (num, _) = e3.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
def test_unicodePwd_clear_set(self):
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS4\"".encode('utf-16-le')) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e4:
+ (num, msg) = e4.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg)
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS2\"".encode('utf-16-le')) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e5:
+ (num, msg) = e5.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('0000052D' in msg)
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e6:
+ (num, _) = e6.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
def test_dBCSPwd_hash_change(self):
dBCSPwd: YYYYYYYYYYYYYYYY
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e7:
+ (num, _) = e7.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
def test_userPassword_clear_set(self):
userPassword: thatsAcomplPASS4
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e8:
+ (num, msg) = e8.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg)
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e9:
+ (num, msg) = e9.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('0000052D' in msg)
FLAG_MOD_REPLACE, "clearTextPassword")
self.ldb.modify(m)
# this passes against s4
- except LdbError, (num, msg):
+ except LdbError as e10:
+ (num, msg) = e10.args
# "NO_SUCH_ATTRIBUTE" is returned by Windows -> ignore it
if num != ERR_NO_SUCH_ATTRIBUTE:
raise LdbError(num, msg)
clearTextPassword:: """ + base64.b64encode("thatsAcomplPASS2".encode('utf-16-le')) + """
""")
# this passes against s4
- except LdbError, (num, msg):
+ except LdbError as e11:
+ (num, msg) = e11.args
# "NO_SUCH_ATTRIBUTE" is returned by Windows -> ignore it
if num != ERR_NO_SUCH_ATTRIBUTE:
raise LdbError(num, msg)
clearTextPassword:: """ + base64.b64encode("thatsAcomplPASS4".encode('utf-16-le')) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e12:
+ (num, msg) = e12.args
# "NO_SUCH_ATTRIBUTE" is returned by Windows -> ignore it
if num != ERR_NO_SUCH_ATTRIBUTE:
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
clearTextPassword:: """ + base64.b64encode("thatsAcomplPASS2".encode('utf-16-le')) + """
""")
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e13:
+ (num, msg) = e13.args
# "NO_SUCH_ATTRIBUTE" is returned by Windows -> ignore it
if num != ERR_NO_SUCH_ATTRIBUTE:
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
userPassword: thatsAcomplPASS1
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e14:
+ (num, _) = e14.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
userPassword: thatsAcomplPASS1
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e15:
+ (num, _) = e15.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
delete: userPassword
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e16:
+ (num, _) = e16.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
delete: userPassword
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e17:
+ (num, _) = e17.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
userPassword: thatsAcomplPASS1
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e18:
+ (num, _) = e18.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
userPassword: thatsAcomplPASS1
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e19:
+ (num, _) = e19.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
try:
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e20:
+ (num, _) = e20.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e21:
+ (num, _) = e21.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e22:
+ (num, _) = e22.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e23:
+ (num, _) = e23.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e24:
+ (num, _) = e24.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e25:
+ (num, _) = e25.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
try:
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e26:
+ (num, _) = e26.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
userPassword: thatsAcomplPASS2
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e27:
+ (num, _) = e27.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
try:
userPassword: thatsAcomplPASS3
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e28:
+ (num, _) = e28.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
userPassword: thatsAcomplPASS3
""")
self.fail()
- except LdbError, (num, _):
+ except LdbError as e29:
+ (num, _) = e29.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# Reverse order does work
unicodePwd:: """ + base64.b64encode("\"thatsAcomplPASS3\"".encode('utf-16-le')) + """
""")
# this passes against s4
- except LdbError, (num, _):
+ except LdbError as e30:
+ (num, _) = e30.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
try:
userPassword: thatsAcomplPASS4
""")
# this passes against s4
- except LdbError, (num, _):
+ except LdbError as e31:
+ (num, _) = e31.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
# Several password changes at once are allowed
"objectclass": "user",
"unicodePwd": [] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e32:
+ (num, _) = e32.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
"objectclass": "user",
"dBCSPwd": [] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e33:
+ (num, _) = e33.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
"objectclass": "user",
"userPassword": [] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e34:
+ (num, _) = e34.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
try:
"objectclass": "user",
"clearTextPassword": [] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e35:
+ (num, _) = e35.args
self.assertTrue(num == ERR_CONSTRAINT_VIOLATION or
num == ERR_NO_SUCH_ATTRIBUTE) # for Windows
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e36:
+ (num, _) = e36.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e37:
+ (num, _) = e37.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e38:
+ (num, _) = e38.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e39:
+ (num, _) = e39.args
self.assertTrue(num == ERR_CONSTRAINT_VIOLATION or
num == ERR_NO_SUCH_ATTRIBUTE) # for Windows
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e40:
+ (num, _) = e40.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e41:
+ (num, _) = e41.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e42:
+ (num, _) = e42.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e43:
+ (num, _) = e43.args
self.assertTrue(num == ERR_UNWILLING_TO_PERFORM or
num == ERR_NO_SUCH_ATTRIBUTE) # for Windows
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e44:
+ (num, _) = e44.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e45:
+ (num, _) = e45.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e46:
+ (num, _) = e46.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
try:
self.ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e47:
+ (num, _) = e47.args
self.assertTrue(num == ERR_CONSTRAINT_VIOLATION or
num == ERR_NO_SUCH_ATTRIBUTE) # for Windows
try:
self.samdb.add(o)
self.fail("Failed to fail to add %s" % o['dn'])
- except ldb.LdbError as (ecode, emsg):
+ except ldb.LdbError as e:
+ (ecode, emsg) = e.args
if ecode != ldb.ERR_REFERRAL:
print emsg
self.fail("Adding %s: ldb error: %s %s, wanted referral" %
try:
self.samdb.modify(msg)
self.fail("Failed to fail to modify %s %s" % (dn, attr))
- except ldb.LdbError as (ecode, emsg):
+ except ldb.LdbError as e1:
+ (ecode, emsg) = e1.args
if ecode != ldb.ERR_REFERRAL:
self.fail("Failed to REFER when trying to modify %s %s" %
(dn, attr))
try:
self.samdb.modify(m)
self.fail("Failed to fail to modify %s %s" % (dn, attr))
- except ldb.LdbError as (ecode, emsg):
+ except ldb.LdbError as e2:
+ (ecode, emsg) = e2.args
if ecode != ldb.ERR_REFERRAL:
self.fail("Failed to REFER when trying to modify %s %s" %
(dn, attr))
try:
self.samdb.modify(m)
self.fail("Failed to fail to modify %s %s" % (dn, attr))
- except ldb.LdbError as (ecode, emsg):
+ except ldb.LdbError as e3:
+ (ecode, emsg) = e3.args
if ecode != ldb.ERR_REFERRAL:
self.fail("Failed to REFER when trying to modify %s %s" %
(dn, attr))
try:
self.samdb.delete(dn)
self.fail("Failed to fail to delete %s" % (dn))
- except ldb.LdbError as (ecode, emsg):
+ except ldb.LdbError as e4:
+ (ecode, emsg) = e4.args
if ecode != ldb.ERR_REFERRAL:
print ecode, emsg
self.fail("Failed to REFER when trying to delete %s" % dn)
try:
self.samdb.delete(dn)
self.fail("Failed to fail to delete %s" % (dn))
- except ldb.LdbError as (ecode, emsg):
+ except ldb.LdbError as e5:
+ (ecode, emsg) = e5.args
if ecode != ldb.ERR_NO_SUCH_OBJECT:
print ecode, emsg
self.fail("Failed to NO_SUCH_OBJECT when trying to delete "
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e1:
+ (num, msg) = e1.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e2:
+ (num, msg) = e2.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e3:
+ (num, msg) = e3.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e4:
+ (num, msg) = e4.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e5:
+ (num, msg) = e5.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e6:
+ (num, msg) = e6.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e7:
+ (num, msg) = e7.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
ldb_lockout = SamDB(url=self.host_url, credentials=creds_lockout, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e8:
+ (num, msg) = e8.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
try:
fn(*args, **kwargs)
self.fail("failed to raise ldap referral")
- except ldb.LdbError as (code, msg):
+ except ldb.LdbError as e9:
+ (code, msg) = e9.args
self.assertEqual(code, ldb.ERR_REFERRAL,
"expected referral, got %s %s" % (code, msg))
try:
self.rwdc_db.add(o)
- except ldb.LdbError as (ecode, emsg):
+ except ldb.LdbError as e:
+ (ecode, emsg) = e.args
self.fail("Failed to add %s to rwdc: ldb error: %s %s" %
(ecode, emsg))
session_info=system_session(LP), lp=LP)
if errno is not None:
self.fail("logon failed to fail with ldb error %s" % errno)
- except ldb.LdbError as (code, msg):
+ except ldb.LdbError as e10:
+ (code, msg) = e10.args
if code != errno:
if errno is None:
self.fail("logon incorrectly raised ldb error (code=%s)" %
try:
ldb = SamDB(url=self.host_url, credentials=fail_creds, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e11:
+ (num, msg) = e11.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
try:
ldb = SamDB(url=self.host_url, credentials=fail_creds, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e12:
+ (num, msg) = e12.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
try:
ldb = SamDB(url=self.host_url, credentials=fail_creds, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e13:
+ (num, msg) = e13.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
try:
ldb = SamDB(url=self.host_url, credentials=fail_creds, lp=self.lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e14:
+ (num, msg) = e14.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
"objectclass": "user",
"sAMAccountName": "administrator"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e9:
+ (num, _) = e9.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"objectclass": "user",
"sAMAccountName": []})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e10:
+ (num, _) = e10.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"objectclass": "user",
"primaryGroupID": "0"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e11:
+ (num, _) = e11.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"objectclass": "user",
"primaryGroupID": str(group_rid_1)})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e12:
+ (num, _) = e12.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e13:
+ (num, _) = e13.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
# Test to see how we should behave when the account isn't a user
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e14:
+ (num, _) = e14.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
# Test default primary groups on add operations
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e15:
+ (num, _) = e15.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# But to reset the actual "sAMAccountName" should still be possible
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e16:
+ (num, _) = e16.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Try to make group 1 primary - should be denied since it is not yet
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e17:
+ (num, _) = e17.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Make group 1 secondary
try:
ldb.delete("cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e18:
+ (num, _) = e18.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# Try to add group 1 also as secondary - should be denied
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e19:
+ (num, _) = e19.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# Try to add invalid member to group 1 - should be denied
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e20:
+ (num, _) = e20.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
# Make group 2 secondary
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e21:
+ (num, _) = e21.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Delete invalid group member
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e22:
+ (num, _) = e22.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Also this should be denied
"objectclass": "user",
"primaryGroupID": "0"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e23:
+ (num, _) = e23.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Recreate user accounts
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e24:
+ (num, _) = e24.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# Already added, but as <SID=...>
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e25:
+ (num, _) = e25.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
# Invalid member
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e26:
+ (num, _) = e26.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
# Invalid member
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e27:
+ (num, _) = e27.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
# Invalid member
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e28:
+ (num, _) = e28.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e29:
+ (num, _) = e29.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
# Delete protection tests
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e30:
+ (num, _) = e30.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e31:
+ (num, _) = e31.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e32:
+ (num, _) = e32.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e33:
+ (num, _) = e33.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e34:
+ (num, _) = e34.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
# Delete protection tests
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e2:
+ (num, _) = e2.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e3:
+ (num, _) = e3.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"objectclass": "group",
"primaryGroupToken": "100"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e35:
+ (num, _) = e35.args
self.assertEquals(num, ERR_UNDEFINED_ATTRIBUTE_TYPE)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e36:
+ (num, _) = e36.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"objectclass": "group",
"groupType": "0"})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e37:
+ (num, _) = e37.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
"objectclass": "group",
"groupType": str(GTYPE_SECURITY_BUILTIN_LOCAL_GROUP)})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e38:
+ (num, _) = e38.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e39:
+ (num, _) = e39.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Security groups
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e40:
+ (num, _) = e40.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Change to "universal"
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e41:
+ (num, _) = e41.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Change to "builtin local" (shouldn't work)
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e42:
+ (num, _) = e42.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e43:
+ (num, _) = e43.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Change back to "global"
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e44:
+ (num, _) = e44.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Distribution groups
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e45:
+ (num, _) = e45.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Change to "universal"
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e46:
+ (num, _) = e46.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Change back to "universal"
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e47:
+ (num, _) = e47.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
# Make group 2 secondary
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e48:
+ (num, _) = e48.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Change to "universal"
FLAG_MOD_REPLACE, "groupType")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e49:
+ (num, _) = e49.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# Change back to "universal"
"objectclass": "user",
"pwdLastSet": str(1)})
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e50:
+ (num, msg) = e50.args
self.assertEquals(num, ERR_OTHER)
self.assertTrue('00000057' in msg)
"objectclass": "user",
"pwdLastSet": str(lastset)})
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e51:
+ (num, msg) = e51.args
self.assertEquals(num, ERR_OTHER)
self.assertTrue('00000057' in msg)
"pwdLastSet")
ldb.modify(m)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e52:
+ (num, msg) = e52.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
self.assertTrue('00002085' in msg)
"pwdLastSet")
ldb.modify(m)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e53:
+ (num, msg) = e53.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
self.assertTrue('00002085' in msg)
"pwdLastSet")
ldb.modify(m)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e54:
+ (num, msg) = e54.args
self.assertEquals(num, ERR_OTHER)
self.assertTrue('00000057' in msg)
simple_ldb = SamDB(url=host, credentials=simple_creds, lp=lp)
self.assertIsNotNone(simple_ldb)
simple_ldb = None
- except LdbError, (num, msg):
+ except LdbError as e55:
+ (num, msg) = e55.args
if num != ERR_STRONG_AUTH_REQUIRED:
raise
requires_strong_auth = True
try:
ldb_fail = SamDB(url=host, credentials=sasl_wrong_creds, lp=lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e56:
+ (num, msg) = e56.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
self.assertTrue(error_msg_sasl_wrong_pw in msg)
try:
ldb_fail = SamDB(url=host, credentials=simple_wrong_creds, lp=lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e4:
+ (num, msg) = e4.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_simple_wrong_pw)
try:
ldb_fail = SamDB(url=host, credentials=sasl_wrong_creds, lp=lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e57:
+ (num, msg) = e57.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_sasl_wrong_pw)
try:
ldb_fail = SamDB(url=host, credentials=sasl_creds, lp=lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e58:
+ (num, msg) = e58.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_sasl_must_change)
try:
ldb_fail = SamDB(url=host, credentials=simple_wrong_creds, lp=lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e5:
+ (num, msg) = e5.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_simple_wrong_pw)
try:
ldb_fail = SamDB(url=host, credentials=simple_creds, lp=lp)
self.fail()
- except LdbError, (num, msg):
+ except LdbError as e6:
+ (num, msg) = e6.args
self.assertEquals(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_simple_must_change)
"objectclass": "user",
"userAccountControl": str(UF_TEMP_DUPLICATE_ACCOUNT)})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e59:
+ (num, _) = e59.args
self.assertEquals(num, ERR_OTHER)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"objectclass": "user",
"userAccountControl": str(UF_SERVER_TRUST_ACCOUNT)})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e60:
+ (num, _) = e60.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectclass": "user",
"userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT)})
- except LdbError, (num, _):
+ except LdbError as e61:
+ (num, _) = e61.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectclass": "user",
"userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT | UF_PARTIAL_SECRETS_ACCOUNT)})
- except LdbError, (num, _):
+ except LdbError as e62:
+ (num, _) = e62.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
"objectclass": "user",
"userAccountControl": str(UF_INTERDOMAIN_TRUST_ACCOUNT)})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e63:
+ (num, _) = e63.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
m["userAccountControl"] = MessageElement("0",
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
- except LdbError, (num, _):
+ except LdbError as e64:
+ (num, _) = e64.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
str(UF_NORMAL_ACCOUNT),
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
- except LdbError, (num, _):
+ except LdbError as e65:
+ (num, _) = e65.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e66:
+ (num, _) = e66.args
self.assertEquals(num, ERR_OTHER)
try:
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e67:
+ (num, _) = e67.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e68:
+ (num, _) = e68.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e69:
+ (num, _) = e69.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# With a computer object
"objectclass": "computer",
"userAccountControl": str(UF_TEMP_DUPLICATE_ACCOUNT)})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e70:
+ (num, _) = e70.args
self.assertEquals(num, ERR_OTHER)
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
"dn": "cn=ldaptestcomputer,cn=computers," + self.base_dn,
"objectclass": "computer",
"userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT)})
- except LdbError, (num, _):
+ except LdbError as e71:
+ (num, _) = e71.args
self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
"objectclass": "computer",
"userAccountControl": str(UF_INTERDOMAIN_TRUST_ACCOUNT)})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e72:
+ (num, _) = e72.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
m["userAccountControl"] = MessageElement("0",
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
- except LdbError, (num, _):
+ except LdbError as e73:
+ (num, _) = e73.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
str(UF_NORMAL_ACCOUNT),
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
- except LdbError, (num, _):
+ except LdbError as e74:
+ (num, _) = e74.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e75:
+ (num, _) = e75.args
self.assertEquals(num, ERR_OTHER)
m = Message()
FLAG_MOD_REPLACE, "userAccountControl")
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e76:
+ (num, _) = e76.args
self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# "primaryGroupID" does not change if account type remains the same
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e77:
+ (num, _) = e77.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e78:
+ (num, _) = e78.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e79:
+ (num, _) = e79.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e80:
+ (num, _) = e80.args
self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e81:
+ (num, _) = e81.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e82:
+ (num, _) = e82.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
"objectclass": "group",
"fSMORoleOwner": self.base_dn})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e83:
+ (num, _) = e83.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
try:
"objectclass": "group",
"fSMORoleOwner": [] })
self.fail()
- except LdbError, (num, _):
+ except LdbError as e84:
+ (num, _) = e84.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
# We are able to set it to a valid "nTDSDSA" entry if the server is
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e85:
+ (num, _) = e85.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e86:
+ (num, _) = e86.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
# We are able to set it to a valid "nTDSDSA" entry if the server is
for pr_object in protected_list:
try:
self.ldb.delete(pr_object[0] + "," + pr_object[1] + self.base_dn)
- except LdbError, (num, _):
+ except LdbError as e7:
+ (num, _) = e7.args
self.assertEquals(num, ERR_OTHER)
else:
self.fail("Deleted " + pr_object[0])
try:
self.ldb.rename(pr_object[0] + "," + pr_object[1] + self.base_dn,
pr_object[0] + "2," + pr_object[1] + self.base_dn)
- except LdbError, (num, _):
+ except LdbError as e8:
+ (num, _) = e8.args
self.fail("Could not rename " + pr_object[0])
self.ldb.rename(pr_object[0] + "2," + pr_object[1] + self.base_dn,
class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
try:
self.ldb_admin.search(base=class_dn, attrs=["name"])
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
break
FLAG_MOD_ADD, "enableOptionalFeature")
try:
self.samdb.modify(msg)
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
def test_undelete(self):
try:
self.samdb.rename(str(objDeleted1.dn), usr1)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e1:
+ (num, _) = e1.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
try:
self.samdb.rename(str(objDeleted1.dn), usr1, ["show_deleted:1"])
self.fail()
- except LdbError, (num, _):
+ except LdbError as e2:
+ (num, _) = e2.args
self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
def test_undelete_with_mod(self):
try:
self.restore_deleted_object(self.samdb, objDeleted1.dn, usr1)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e3:
+ (num, _) = e3.args
self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
def test_undelete_cross_nc(self):
try:
self.restore_deleted_object(self.samdb, objDeleted1.dn, c3)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e4:
+ (num, _) = e4.args
self.assertEquals(num, ERR_OPERATIONS_ERROR)
#try to undelete from config to base dn
try:
self.restore_deleted_object(self.samdb, objDeleted2.dn, c4)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e5:
+ (num, _) = e5.args
self.assertEquals(num, ERR_OPERATIONS_ERROR)
#assert undeletion will work in same nc
self.restore_deleted_object(self.samdb, objDeleted1.dn, c4)
def delete_force(self, ldb, dn):
try:
ldb.delete(dn, ["relax:0"])
- except LdbError, (num, _):
+ except LdbError as e:
+ (num, _) = e.args
self.assertEquals(num, ERR_NO_SUCH_OBJECT)
def setUp(self):
try:
self.samdb.modify(m)
self.fail("Unexpectedly able to set userAccountControl to be a DC on %s" % m.dn)
- except LdbError, (enum, estr):
+ except LdbError as e5:
+ (enum, estr) = e5.args
self.assertEqual(ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, enum)
m = ldb.Message()
try:
self.samdb.modify(m)
self.fail("Unexpectedly able to set userAccountControl to be an RODC on %s" % m.dn)
- except LdbError, (enum, estr):
+ except LdbError as e6:
+ (enum, estr) = e6.args
self.assertEqual(ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, enum)
m = ldb.Message()
try:
self.samdb.modify(m)
self.fail("Unexpectedly able to set userAccountControl to be an Workstation on %s" % m.dn)
- except LdbError, (enum, estr):
+ except LdbError as e7:
+ (enum, estr) = e7.args
self.assertEqual(ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, enum)
m = ldb.Message()
ldb.FLAG_MOD_REPLACE, "primaryGroupID")
try:
self.samdb.modify(m)
- except LdbError, (enum, estr):
+ except LdbError as e8:
+ (enum, estr) = e8.args
self.assertEqual(ldb.ERR_UNWILLING_TO_PERFORM, enum)
return
self.fail()
try:
self.samdb.modify(m)
self.fail("Unexpectedly able to set userAccountControl on %s" % m.dn)
- except LdbError, (enum, estr):
+ except LdbError as e9:
+ (enum, estr) = e9.args
self.assertEqual(ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, enum)
m = ldb.Message()
try:
self.samdb.modify(m)
self.fail()
- except LdbError, (enum, estr):
+ except LdbError as e10:
+ (enum, estr) = e10.args
self.assertEqual(ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, enum)
m = ldb.Message()
try:
self.samdb.modify(m)
self.fail("Unexpectedly able to set userAccountControl to be an Workstation on %s" % m.dn)
- except LdbError, (enum, estr):
+ except LdbError as e11:
+ (enum, estr) = e11.args
self.assertEqual(ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, enum)
try:
self.admin_samdb.modify(m)
self.fail("Unexpectedly able to set userAccountControl to UF_WORKSTATION_TRUST_ACCOUNT|UF_PARTIAL_SECRETS_ACCOUNT|UF_TRUSTED_FOR_DELEGATION on %s" % m.dn)
- except LdbError, (enum, estr):
+ except LdbError as e12:
+ (enum, estr) = e12.args
self.assertEqual(ldb.ERR_OTHER, enum)
m = ldb.Message()
self.samdb.modify(m)
if (bit in priv_bits):
self.fail("Unexpectedly able to set userAccountControl bit 0x%08X on %s" % (bit, m.dn))
- except LdbError, (enum, estr):
+ except LdbError as e:
+ (enum, estr) = e.args
if bit in invalid_bits:
self.assertEqual(enum, ldb.ERR_OTHER, "was not able to set 0x%08X on %s" % (bit, m.dn))
# No point going on, try the next bit
if bit in invalid_bits:
self.fail("Should have been unable to set userAccountControl bit 0x%08X on %s" % (bit, m.dn))
- except LdbError, (enum, estr):
+ except LdbError as e1:
+ (enum, estr) = e1.args
if bit in invalid_bits:
self.assertEqual(enum, ldb.ERR_OTHER)
# No point going on, try the next bit
ldb.FLAG_MOD_REPLACE, "userAccountControl")
self.samdb.modify(m)
- except LdbError, (enum, estr):
+ except LdbError as e2:
+ (enum, estr) = e2.args
self.fail("Unable to set userAccountControl bit 0x%08X on %s: %s" % (bit, m.dn, estr))
res = self.admin_samdb.search("%s" % self.base_dn,
if bit in priv_to_remove_bits:
self.fail("Should have been unable to remove userAccountControl bit 0x%08X on %s" % (bit, m.dn))
- except LdbError, (enum, estr):
+ except LdbError as e3:
+ (enum, estr) = e3.args
if bit in priv_to_remove_bits:
self.assertEqual(enum, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
if bit in priv_bits:
self.fail("Unexpectdly able to set userAccountControl bit 0x%08X on %s" % (bit, computername))
- except LdbError, (enum, estr):
+ except LdbError as e4:
+ (enum, estr) = e4.args
if bit in invalid_bits:
self.assertEqual(enum, ldb.ERR_OTHER, "Invalid bit 0x%08X was able to be set on %s" % (bit, computername))
# No point going on, try the next bit
# When creating a new object, you can not ever set the primaryGroupID
self.add_computer_ldap(computername, others={"primaryGroupID": [str(security.DOMAIN_RID_ADMINS)]})
self.fail("Unexpectedly able to set primaryGruopID to be an admin on %s" % computername)
- except LdbError, (enum, estr):
+ except LdbError as e13:
+ (enum, estr) = e13.args
self.assertEqual(enum, ldb.ERR_UNWILLING_TO_PERFORM)
# When creating a new object, you can not ever set the primaryGroupID
self.fail("Unexpectedly able to set primaryGroupID to be other than DCS on %s" % computername)
- except LdbError, (enum, estr):
+ except LdbError as e14:
+ (enum, estr) = e14.args
self.assertEqual(enum, ldb.ERR_UNWILLING_TO_PERFORM)
def test_primarygroupID_priv_member_modify(self):
# When creating a new object, you can not ever set the primaryGroupID
self.fail("Unexpectedly able to set primaryGroupID to be other than DCS on %s" % computername)
- except LdbError, (enum, estr):
+ except LdbError as e15:
+ (enum, estr) = e15.args
self.assertEqual(enum, ldb.ERR_UNWILLING_TO_PERFORM)
git.samba.org / metze / samba / wip.git / commitdiff