# -*- coding: utf-8 -*-
# This is a port of the original in testprogs/ejs/ldap.js
+# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008-2011
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import print_function
import optparse
import sys
import time
sys.path.insert(0, "bin/python")
import samba
-samba.ensure_external_module("testtools", "testtools")
-samba.ensure_external_module("subunit", "subunit/python")
-
+from samba.tests.subunitrun import SubunitOptions, TestProgram
import samba.getopt as options
from samba.auth import system_session
SYSTEM_FLAG_CONFIG_ALLOW_RENAME, SYSTEM_FLAG_CONFIG_ALLOW_MOVE,
SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE)
-from subunit.run import SubunitTestRunner
-import unittest
-
from samba.ndr import ndr_pack, ndr_unpack
from samba.dcerpc import security, lsa
from samba.tests import delete_force
# use command line creds if available
credopts = options.CredentialsOptions(parser)
parser.add_option_group(credopts)
+subunitopts = SubunitOptions(parser)
+parser.add_option_group(subunitopts)
opts, args = parser.parse_args()
if len(args) < 1:
lp = sambaopts.get_loadparm()
creds = credopts.get_credentials(lp)
-class BasicTests(unittest.TestCase):
+class BasicTests(samba.tests.TestCase):
def setUp(self):
super(BasicTests, self).setUp()
self.schema_dn = ldb.get_schema_basedn().get_linearized()
self.domain_sid = security.dom_sid(ldb.get_domain_sid())
- print "baseDN: %s\n" % self.base_dn
-
delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
delete_force(self.ldb, "cn=Test Secret,cn=system," + self.base_dn)
+ delete_force(self.ldb, "cn=testtimevaluesuser1,cn=users," + self.base_dn)
def test_objectclasses(self):
"""Test objectClass behaviour"""
- print "Test objectClass behaviour"""
-
- # We cannot create LSA-specific objects (oc "secret" or "trustedDomain")
- try:
- self.ldb.add({
- "dn": "cn=Test Secret,cn=system," + self.base_dn,
- "objectClass": "secret" })
- self.fail()
- except LdbError, (num, _):
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
-
# Invalid objectclass specified
try:
self.ldb.add({
"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
"objectClass")
ldb.modify(m)
+ # Add a new auxiliary object class "posixAccount" to "ldaptestuser"
+ m = Message()
+ m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
+ m["objectClass"] = MessageElement("posixAccount", FLAG_MOD_ADD,
+ "objectClass")
+ ldb.modify(m)
+
+ # Be sure that "top" is the first and the (most) structural object class
+ # the last value of the "objectClass" attribute - MS-ADTS 3.1.1.1.4
+ res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
+ scope=SCOPE_BASE, attrs=["objectClass"])
+ self.assertTrue(len(res) == 1)
+ self.assertEquals(res[0]["objectClass"][0], "top")
+ self.assertEquals(res[0]["objectClass"][len(res[0]["objectClass"])-1], "user")
+
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
def test_system_only(self):
"""Test systemOnly objects"""
- print "Test systemOnly objects"""
-
try:
self.ldb.add({
"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)
def test_invalid_parent(self):
"""Test adding an object with invalid parent"""
- print "Test adding an object with invalid parent"""
-
try:
self.ldb.add({
"dn": "cn=ldaptestgroup,cn=thisdoesnotexist123,"
+ 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)
def test_invalid_attribute(self):
"""Test invalid attributes on schema/objectclasses"""
- print "Test invalid attributes on schema/objectclasses"""
-
# attributes not in schema test
# add operation
"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)
+ #
+ # When searching the unknown attribute should be ignored
+ expr = "(|(cn=ldaptestgroup)(thisdoesnotexist=x))"
+ res = ldb.search(base=self.base_dn,
+ expression=expr,
+ scope=SCOPE_SUBTREE)
+ self.assertTrue(len(res) == 1,
+ "Search including unknown attribute failed")
+
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
# attributes not in objectclasses and mandatory attributes missing test
"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)
def test_single_valued_attributes(self):
"""Test single-valued attributes"""
- print "Test single-valued attributes"""
-
try:
self.ldb.add({
"dn": "cn=ldaptestgroup,cn=users," + 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)
+ def test_single_valued_linked_attributes(self):
+ """Test managedBy, a single-valued linked attribute.
+
+ (The single-valuedness of this is enforced differently, in
+ repl_meta_data.c)
+ """
+ ou = 'OU=svla,%s' % (self.base_dn)
+
+ delete_force(self.ldb, ou, controls=['tree_delete:1'])
+
+ self.ldb.add({'objectclass': 'organizationalUnit',
+ 'dn': ou})
+
+
+ managers = []
+ for x in range(3):
+ m = "cn=manager%d,%s" % (x, ou)
+ self.ldb.add({
+ "dn": m,
+ "objectclass": "user"})
+ managers.append(m)
+
+ try:
+ self.ldb.add({
+ "dn": "cn=group1," + ou,
+ "objectclass": "group",
+ "managedBy": managers
+ })
+ self.fail("failed to fail to add multiple managedBy attributes")
+ except LdbError as e36:
+ (num, _) = e36.args
+ self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+
+ managee = "cn=group2," + ou
+ self.ldb.add({
+ "dn": managee,
+ "objectclass": "group",
+ "managedBy": [managers[0]]})
+
+ m = Message()
+ m.dn = Dn(ldb, managee)
+ m["managedBy"] = MessageElement(managers, FLAG_MOD_REPLACE,
+ "managedBy")
+ try:
+ ldb.modify(m)
+ self.fail()
+ except LdbError as e37:
+ (num, _) = e37.args
+ self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+
+ m = Message()
+ m.dn = Dn(ldb, managee)
+ m["managedBy"] = MessageElement(managers[1], FLAG_MOD_REPLACE,
+ "managedBy")
+ ldb.modify(m)
+
+ m = Message()
+ m.dn = Dn(ldb, managee)
+ m["managedBy"] = MessageElement(managers[2], FLAG_MOD_ADD,
+ "managedBy")
+ try:
+ ldb.modify(m)
+ self.fail()
+ except LdbError as e38:
+ (num, _) = e38.args
+ self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+
+ self.ldb.delete(ou, ['tree_delete:1'])
+
+
+ def test_multivalued_attributes(self):
+ """Test multi-valued attributes"""
+ ou = 'OU=mvattr,%s' % (self.base_dn)
+ delete_force(self.ldb, ou, controls=['tree_delete:1'])
+ self.ldb.add({'objectclass': 'organizationalUnit',
+ 'dn': ou})
+
+ # beyond 1210, Win2012r2 gives LDAP_ADMIN_LIMIT_EXCEEDED
+ ranges = (3, 30, 300, 1210)
+
+ for n in ranges:
+ self.ldb.add({
+ "dn": "cn=ldaptestuser%d,%s" % (n, ou),
+ "objectclass": "user",
+ "carLicense": ["car%d" % x for x in range(n)]})
+
+ # add some more
+ for n in ranges:
+ m = Message()
+ m.dn = Dn(ldb, "cn=ldaptestuser%d,%s" % (n, ou))
+ m["carLicense"] = MessageElement(["another"],
+ FLAG_MOD_ADD,
+ "carLicense")
+ ldb.modify(m)
+
+ m = Message()
+ m.dn = Dn(ldb, "cn=ldaptestuser%d,%s" % (n, ou))
+ m["carLicense"] = MessageElement(["foo%d" % x for x in range(4)],
+ FLAG_MOD_ADD,
+ "carLicense")
+ ldb.modify(m)
+
+ m = Message()
+ m.dn = Dn(ldb, "cn=ldaptestuser%d,%s" % (n, ou))
+ m["carLicense"] = MessageElement(["bar%d" % x for x in range(40)],
+ FLAG_MOD_ADD,
+ "carLicense")
+ ldb.modify(m)
+
+ for n in ranges:
+ m = Message()
+ dn = "cn=ldaptestuser%d,%s" % (n, ou)
+ m.dn = Dn(ldb, dn)
+ m["carLicense"] = MessageElement(["replacement"],
+ FLAG_MOD_REPLACE,
+ "carLicense")
+ ldb.modify(m)
+
+ m = Message()
+ m.dn = Dn(ldb, dn)
+ m["carLicense"] = MessageElement(["replacement%d" % x for x in range(n)],
+ FLAG_MOD_REPLACE,
+ "carLicense")
+ ldb.modify(m)
+
+ m = Message()
+ m.dn = Dn(ldb, dn)
+ m["carLicense"] = MessageElement(["again%d" % x for x in range(n)],
+ FLAG_MOD_REPLACE,
+ "carLicense")
+ ldb.modify(m)
+
+ m = Message()
+ m.dn = Dn(ldb, dn)
+ m["carLicense"] = MessageElement(["andagain%d" % x for x in range(n)],
+ FLAG_MOD_REPLACE,
+ "carLicense")
+ ldb.modify(m)
+
+ self.ldb.delete(ou, ['tree_delete:1'])
+
+
def test_attribute_ranges(self):
"""Test attribute ranges"""
- print "Test attribute ranges"""
-
# Too short (min. 1)
try:
ldb.add({
- "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
+ "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"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)
# self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
ldb.add({
- "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
+ "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
"objectClass": "person" })
# Too short (min. 1)
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)
def test_empty_messages(self):
"""Test empty messages"""
- print "Test empty messages"""
-
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
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)
def test_empty_attributes(self):
"""Test empty attributes"""
- print "Test empty attributes"""
-
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
m["objectClass"] = MessageElement("group", FLAG_MOD_ADD, "objectClass")
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)
def test_instanceType(self):
"""Tests the 'instanceType' attribute"""
- print "Tests the 'instanceType' attribute"""
-
# The instance type is single-valued
try:
self.ldb.add({
"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)
+ #only write is allowed with NC_HEAD for originating updates
+ try:
+ self.ldb.add({
+ "dn": "cn=ldaptestuser2,cn=users," + self.base_dn,
+ "objectclass": "user",
+ "instanceType": "3" })
+ self.fail()
+ 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)
+
def test_distinguished_name(self):
"""Tests the 'distinguishedName' attribute"""
- print "Tests the 'distinguishedName' attribute"""
-
# The "dn" shortcut isn't supported
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,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
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
m["dn"] = MessageElement(
- "cn=ldaptestgroup,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
+ "cn=ldaptestgroup,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
"dn")
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()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
m["distinguishedName"] = MessageElement(
- "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_ADD,
+ "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_ADD,
"distinguishedName")
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ except LdbError as e55:
+ (num, _) = e55.args
+ self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
m["distinguishedName"] = MessageElement(
- "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
+ "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
"distinguishedName")
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
+ except LdbError as e56:
+ (num, _) = e56.args
self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
m["distinguishedName"] = MessageElement(
- "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_DELETE,
+ "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_DELETE,
"distinguishedName")
try:
ldb.modify(m)
self.fail()
- except LdbError, (num, _):
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ 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)
def test_rdn_name(self):
"""Tests the RDN"""
- print "Tests the RDN"""
-
# Search
# empty RDN
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)
# what the rDN length constraints are
def DISABLED_test_largeRDN(self):
"""Testing large rDN (limit 64 characters)"""
- rdn = "CN=a012345678901234567890123456789012345678901234567890123456789012";
+ rdn = "CN=a012345678901234567890123456789012345678901234567890123456789012"
delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
ldif = """
dn: %s,%s""" % (rdn,self.base_dn) + """
self.ldb.add_ldif(ldif)
delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
- rdn = "CN=a0123456789012345678901234567890123456789012345678901234567890120";
+ rdn = "CN=a0123456789012345678901234567890123456789012345678901234567890120"
delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
try:
ldif = """
"""
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))
def test_rename(self):
"""Tests the rename operation"""
- print "Tests the rename operations"""
-
try:
# 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):
"""Tests the rename operation twice - this corresponds to a past bug"""
- print "Tests the rename twice operation"""
-
self.ldb.add({
"dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
"objectclass": "user" })
"objectclass": "user" })
ldb.rename("cn=ldaptestuser5,cn=Users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
res = ldb.search(expression="cn=ldaptestuser5")
- print "Found %u records" % len(res)
self.assertEquals(len(res), 1, "Wrong number of hits for cn=ldaptestuser5")
res = ldb.search(expression="(&(cn=ldaptestuser5)(objectclass=user))")
- print "Found %u records" % len(res)
self.assertEquals(len(res), 1, "Wrong number of hits for (&(cn=ldaptestuser5)(objectclass=user))")
delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
def test_objectGUID(self):
"""Test objectGUID behaviour"""
- print "Testing objectGUID behaviour\n"
-
# The objectGUID cannot directly be set
try:
self.ldb.add_ldif("""
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({
"dn": "cn=ldaptestcontainer," + self.base_dn,
"objectClass": "container" })
- res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
- scope=SCOPE_BASE,
- attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged"])
- self.assertTrue(len(res) == 1)
- self.assertTrue("objectGUID" in res[0])
- self.assertTrue("uSNCreated" in res[0])
- self.assertTrue("uSNChanged" in res[0])
- self.assertTrue("whenCreated" in res[0])
- self.assertTrue("whenChanged" in res[0])
-
- delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
-
- # All the following attributes are specificable on add operations
- self.ldb.add({
- "dn": "cn=ldaptestcontainer," + self.base_dn,
- "objectClass": "container",
- "uSNCreated" : "1",
- "uSNChanged" : "1",
- "whenCreated": timestring(long(time.time())),
- "whenChanged": timestring(long(time.time())) })
-
- res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
- scope=SCOPE_BASE,
- attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged"])
- self.assertTrue(len(res) == 1)
- self.assertTrue("objectGUID" in res[0])
- self.assertTrue("uSNCreated" in res[0])
- self.assertFalse(res[0]["uSNCreated"][0] == "1") # these are corrected
- self.assertTrue("uSNChanged" in res[0])
- self.assertFalse(res[0]["uSNChanged"][0] == "1") # these are corrected
-
- delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
-
- # All this attributes are specificable on add operations
- self.ldb.add({
- "dn": "cn=ldaptestcontainer," + self.base_dn,
- "objectclass": "container",
- "uSNCreated" : "1",
- "uSNChanged" : "1",
- "whenCreated": timestring(long(time.time())),
- "whenChanged": timestring(long(time.time())) })
-
- res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
- scope=SCOPE_BASE,
- attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged"])
- self.assertTrue(len(res) == 1)
- self.assertTrue("objectGUID" in res[0])
- self.assertTrue("uSNCreated" in res[0])
- self.assertFalse(res[0]["uSNCreated"][0] == "1") # these are corrected
- self.assertTrue("uSNChanged" in res[0])
- self.assertFalse(res[0]["uSNChanged"][0] == "1") # these are corrected
- self.assertTrue("whenCreated" in res[0])
- self.assertTrue("whenChanged" in res[0])
-
# The objectGUID cannot directly be changed
try:
self.ldb.modify_ldif("""
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)
def test_parentGUID(self):
"""Test parentGUID behaviour"""
- print "Testing parentGUID behaviour\n"
-
self.ldb.add({
"dn": "cn=parentguidtest,cn=users," + self.base_dn,
"objectclass":"user",
- "samaccountname":"parentguidtest"});
+ "samaccountname":"parentguidtest"})
res1 = ldb.search(base="cn=parentguidtest,cn=users," + self.base_dn, scope=SCOPE_BASE,
- attrs=["parentGUID", "samaccountname"]);
+ attrs=["parentGUID", "samaccountname"])
res2 = ldb.search(base="cn=users," + self.base_dn,scope=SCOPE_BASE,
- attrs=["objectGUID"]);
+ attrs=["objectGUID"])
res3 = ldb.search(base=self.base_dn, scope=SCOPE_BASE,
- attrs=["parentGUID"]);
+ attrs=["parentGUID"])
res4 = ldb.search(base=self.configuration_dn, scope=SCOPE_BASE,
- attrs=["parentGUID"]);
+ attrs=["parentGUID"])
res5 = ldb.search(base=self.schema_dn, scope=SCOPE_BASE,
- attrs=["parentGUID"]);
+ attrs=["parentGUID"])
"""Check if the parentGUID is valid """
- self.assertEquals(res1[0]["parentGUID"], res2[0]["objectGUID"]);
+ self.assertEquals(res1[0]["parentGUID"], res2[0]["objectGUID"])
"""Check if it returns nothing when there is no parent object - default NC"""
has_parentGUID = False
if key == "parentGUID":
has_parentGUID = True
break
- self.assertFalse(has_parentGUID);
+ self.assertFalse(has_parentGUID)
"""Check if it returns nothing when there is no parent object - configuration NC"""
has_parentGUID = False
if key == "parentGUID":
has_parentGUID = True
break
- self.assertFalse(has_parentGUID);
+ self.assertFalse(has_parentGUID)
"""Check if it returns nothing when there is no parent object - schema NC"""
has_parentGUID = False
if key == "parentGUID":
has_parentGUID = True
break
- self.assertFalse(has_parentGUID);
+ self.assertFalse(has_parentGUID)
"""Ensures that if you look for another object attribute after the constructed
parentGUID, it will return correctly"""
break
self.assertTrue(has_another_attribute)
self.assertTrue(len(res1[0]["samaccountname"]) == 1)
- self.assertEquals(res1[0]["samaccountname"][0], "parentguidtest");
+ self.assertEquals(res1[0]["samaccountname"][0], "parentguidtest")
- print "Testing parentGUID behaviour on rename\n"
+ # Testing parentGUID behaviour on rename\
self.ldb.add({
"dn": "cn=testotherusers," + self.base_dn,
- "objectclass":"container"});
+ "objectclass":"container"})
res1 = ldb.search(base="cn=testotherusers," + self.base_dn,scope=SCOPE_BASE,
- attrs=["objectGUID"]);
+ attrs=["objectGUID"])
ldb.rename("cn=parentguidtest,cn=users," + self.base_dn,
- "cn=parentguidtest,cn=testotherusers," + self.base_dn);
+ "cn=parentguidtest,cn=testotherusers," + self.base_dn)
res2 = ldb.search(base="cn=parentguidtest,cn=testotherusers," + self.base_dn,
scope=SCOPE_BASE,
- attrs=["parentGUID"]);
- self.assertEquals(res1[0]["objectGUID"], res2[0]["parentGUID"]);
+ attrs=["parentGUID"])
+ self.assertEquals(res1[0]["objectGUID"], res2[0]["parentGUID"])
delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
+ def test_usnChanged(self):
+ """Test usnChanged behaviour"""
+
+ self.ldb.add({
+ "dn": "cn=ldaptestcontainer," + self.base_dn,
+ "objectClass": "container" })
+
+ res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertFalse("description" in res[0])
+ self.assertTrue("objectGUID" in res[0])
+ self.assertTrue("uSNCreated" in res[0])
+ self.assertTrue("uSNChanged" in res[0])
+ self.assertTrue("whenCreated" in res[0])
+ self.assertTrue("whenChanged" in res[0])
+
+ delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
+
+ # All this attributes are specificable on add operations
+ self.ldb.add({
+ "dn": "cn=ldaptestcontainer," + self.base_dn,
+ "objectclass": "container",
+ "uSNCreated" : "1",
+ "uSNChanged" : "1",
+ "whenCreated": timestring(long(time.time())),
+ "whenChanged": timestring(long(time.time())) })
+
+ res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertFalse("description" in res[0])
+ self.assertTrue("objectGUID" in res[0])
+ self.assertTrue("uSNCreated" in res[0])
+ self.assertFalse(res[0]["uSNCreated"][0] == "1") # these are corrected
+ self.assertTrue("uSNChanged" in res[0])
+ self.assertFalse(res[0]["uSNChanged"][0] == "1") # these are corrected
+ self.assertTrue("whenCreated" in res[0])
+ self.assertTrue("whenChanged" in res[0])
+
+ ldb.modify_ldif("""
+dn: cn=ldaptestcontainer,""" + self.base_dn + """
+changetype: modify
+replace: description
+""")
+
+ res2 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["uSNCreated", "uSNChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertFalse("description" in res2[0])
+ self.assertEqual(res[0]["usnCreated"], res2[0]["usnCreated"])
+ self.assertEqual(res[0]["usnCreated"], res2[0]["usnChanged"])
+ self.assertEqual(res[0]["usnChanged"], res2[0]["usnChanged"])
+
+ ldb.modify_ldif("""
+dn: cn=ldaptestcontainer,""" + self.base_dn + """
+changetype: modify
+replace: description
+description: test
+""")
+
+ res3 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["uSNCreated", "uSNChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertTrue("description" in res3[0])
+ self.assertEqual("test", str(res3[0]["description"][0]))
+ self.assertEqual(res[0]["usnCreated"], res3[0]["usnCreated"])
+ self.assertNotEqual(res[0]["usnCreated"], res3[0]["usnChanged"])
+ self.assertNotEqual(res[0]["usnChanged"], res3[0]["usnChanged"])
+
+ ldb.modify_ldif("""
+dn: cn=ldaptestcontainer,""" + self.base_dn + """
+changetype: modify
+replace: description
+description: test
+""")
+
+ res4 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["uSNCreated", "uSNChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertTrue("description" in res4[0])
+ self.assertEqual("test", str(res4[0]["description"][0]))
+ self.assertEqual(res[0]["usnCreated"], res4[0]["usnCreated"])
+ self.assertNotEqual(res3[0]["usnCreated"], res4[0]["usnChanged"])
+ self.assertEqual(res3[0]["usnChanged"], res4[0]["usnChanged"])
+
+ ldb.modify_ldif("""
+dn: cn=ldaptestcontainer,""" + self.base_dn + """
+changetype: modify
+replace: description
+description: test2
+""")
+
+ res5 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["uSNCreated", "uSNChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertTrue("description" in res5[0])
+ self.assertEqual("test2", str(res5[0]["description"][0]))
+ self.assertEqual(res[0]["usnCreated"], res5[0]["usnCreated"])
+ self.assertNotEqual(res3[0]["usnChanged"], res5[0]["usnChanged"])
+
+ ldb.modify_ldif("""
+dn: cn=ldaptestcontainer,""" + self.base_dn + """
+changetype: modify
+delete: description
+description: test2
+""")
+
+ res6 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["uSNCreated", "uSNChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertFalse("description" in res6[0])
+ self.assertEqual(res[0]["usnCreated"], res6[0]["usnCreated"])
+ self.assertNotEqual(res5[0]["usnChanged"], res6[0]["usnChanged"])
+
+ ldb.modify_ldif("""
+dn: cn=ldaptestcontainer,""" + self.base_dn + """
+changetype: modify
+add: description
+description: test3
+""")
+
+ res7 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["uSNCreated", "uSNChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertTrue("description" in res7[0])
+ self.assertEqual("test3", str(res7[0]["description"][0]))
+ self.assertEqual(res[0]["usnCreated"], res7[0]["usnCreated"])
+ self.assertNotEqual(res6[0]["usnChanged"], res7[0]["usnChanged"])
+
+ ldb.modify_ldif("""
+dn: cn=ldaptestcontainer,""" + self.base_dn + """
+changetype: modify
+delete: description
+""")
+
+ res8 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
+ scope=SCOPE_BASE,
+ attrs=["uSNCreated", "uSNChanged", "description"])
+ self.assertTrue(len(res) == 1)
+ self.assertFalse("description" in res8[0])
+ self.assertEqual(res[0]["usnCreated"], res8[0]["usnCreated"])
+ self.assertNotEqual(res7[0]["usnChanged"], res8[0]["usnChanged"])
+
+ delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
+
def test_groupType_int32(self):
"""Test groupType (int32) behaviour (should appear to be casted to a 32 bit signed integer before comparsion)"""
- print "Testing groupType (int32) behaviour\n"
res1 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
- attrs=["groupType"], expression="groupType=2147483653");
+ attrs=["groupType"], expression="groupType=2147483653")
res2 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
- attrs=["groupType"], expression="groupType=-2147483643");
+ attrs=["groupType"], expression="groupType=-2147483643")
self.assertEquals(len(res1), len(res2))
def test_linked_attributes(self):
"""This tests the linked attribute behaviour"""
- print "Testing linked attribute behaviour\n"
ldb.add({
"dn": "cn=ldaptestgroup,cn=users," + 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()
# Make sure that the "member" attribute for "ldaptestuser" has been
# removed
res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
- scope=SCOPE_BASE, attrs=["member"])
+ scope=SCOPE_BASE, attrs=["member"])
self.assertTrue(len(res) == 1)
self.assertFalse("member" in res[0])
def test_wkguid(self):
"""Test Well known GUID behaviours (including DN+Binary)"""
- print "Test Well known GUID behaviours (including DN+Binary)"""
res = self.ldb.search(base=("<WKGUID=ab1d30f3768811d1aded00c04fd8d5cd,%s>" % self.base_dn), scope=SCOPE_BASE, attrs=[])
self.assertEquals(len(res), 1)
def test_subschemasubentry(self):
"""Test subSchemaSubEntry appears when requested, but not when not requested"""
- print "Test subSchemaSubEntry"""
res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["subSchemaSubEntry"])
self.assertEquals(len(res), 1)
def test_all(self):
"""Basic tests"""
- print "Testing user add"
+ # Testing user add
ldb.add({
"dn": "cn=ldaptestuser,cn=uSers," + self.base_dn,
"cn": "LDAPtest2COMPUTER"
})
self.fail()
- except LdbError, (num, _):
+ except LdbError as e94:
+ (num, _) = e94.args
self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
try:
"objectClass": "computer",
"cn": "ldaptestcomputer3",
"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,
"cn": "LDAPtestCOMPUTER3"
})
- print "Testing ldb.search for (&(cn=ldaptestcomputer3)(objectClass=user))";
- res = ldb.search(self.base_dn, expression="(&(cn=ldaptestcomputer3)(objectClass=user))");
+ # Testing ldb.search for (&(cn=ldaptestcomputer3)(objectClass=user))
+ res = ldb.search(self.base_dn, expression="(&(cn=ldaptestcomputer3)(objectClass=user))")
self.assertEquals(len(res), 1, "Found only %d for (&(cn=ldaptestcomputer3)(objectClass=user))" % len(res))
- self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn));
- self.assertEquals(res[0]["cn"][0], "ldaptestcomputer3");
- self.assertEquals(res[0]["name"][0], "ldaptestcomputer3");
- self.assertEquals(res[0]["objectClass"][0], "top");
- self.assertEquals(res[0]["objectClass"][1], "person");
- self.assertEquals(res[0]["objectClass"][2], "organizationalPerson");
- self.assertEquals(res[0]["objectClass"][3], "user");
- self.assertEquals(res[0]["objectClass"][4], "computer");
+ self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn))
+ self.assertEquals(res[0]["cn"][0], "ldaptestcomputer3")
+ self.assertEquals(res[0]["name"][0], "ldaptestcomputer3")
+ self.assertEquals(res[0]["objectClass"][0], "top")
+ self.assertEquals(res[0]["objectClass"][1], "person")
+ self.assertEquals(res[0]["objectClass"][2], "organizationalPerson")
+ self.assertEquals(res[0]["objectClass"][3], "user")
+ self.assertEquals(res[0]["objectClass"][4], "computer")
self.assertTrue("objectGUID" in res[0])
self.assertTrue("whenCreated" in res[0])
self.assertEquals(res[0]["objectCategory"][0], ("CN=Computer,%s" % ldb.get_schema_basedn()))
- self.assertEquals(int(res[0]["primaryGroupID"][0]), 513);
- self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT);
- self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE);
+ self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
+ self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
+ self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
- print "Testing attribute or value exists behaviour"
+ # Testing attribute or value exists behaviour
try:
ldb.modify_ldif("""
dn: cn=ldaptest2computer,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)
- print "Testing ranged results"
+ # Testing ranged results
ldb.modify_ldif("""
dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
changetype: modify
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE,
attrs=["servicePrincipalName;range=0-*"])
self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- #print len(res[0]["servicePrincipalName;range=0-*"])
self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"])
self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- # print res[0]["servicePrincipalName;range=0-19"].length
self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"])
self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19)
- # print res[0]["servicePrincipalName;range=11-*"][18]
- # print pos_11
- # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
+ # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"])
self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5)
- # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
+ # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"])
self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- # print res[0]["servicePrincipalName"][18]
- # print pos_11
self.assertEquals(len(res[0]["servicePrincipalName"]), 30)
- # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11)
+ # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11)
delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
ldb.add({
"givenname": "testy",
"sn": "ldap user2"})
- print "Testing Ambigious Name Resolution"
+ # Testing Ambigious Name Resolution
# Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))")
self.assertEquals(len(res), 3, "Found only %d of 3 for (&(anr=ldap testy)(objectClass=user))" % len(res))
# res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))")
# self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))")
- print "Testing Renames"
+ # Testing Renames
attrs = ["objectGUID", "objectSid"]
- print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))
res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
# Check rename works with extended/alternate DN forms
ldb.rename("<SID=" + ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0]) + ">" , "cn=ldaptestUSER3,cn=users," + self.base_dn)
- print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))
res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))")
self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
- #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))"
+ #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))"
res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
- #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))"
+ #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))"
res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
- #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))"
+ #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))"
res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
self.assertEquals(len(res), 0, "(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
- # This is a Samba special, and does not exist in real AD
- # print "Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
- # res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
- # if (res.error != 0 || len(res) != 1) {
- # print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
- # self.assertEquals(len(res), 1)
- # }
- # self.assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
- # self.assertEquals(res[0].cn, "ldaptestUSER3")
- # self.assertEquals(res[0].name, "ldaptestUSER3")
-
- print "Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
+ # Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ") - should not work
+ res = ldb.search(expression="(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
+ self.assertEquals(len(res), 0, "Could find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
+
+ # Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")
res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
- self.assertEquals(len(res), 1, "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
+ self.assertEquals(len(res), 1, "Could not find (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
# ensure we cannot add it again
try:
ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + self.base_dn,
- "objectClass": "user",
- "cn": "LDAPtestUSER3"})
+ "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
ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn,
- "objectClass": "user",
- "cn": "LDAPtestUSER3"})
+ "objectClass": "user",
+ "cn": "LDAPtestUSER3"})
# ensure we now cannot rename
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)
ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn, "cn=ldaptestgroup2,cn=users," + self.base_dn)
- print "Testing subtree renames"
+ # Testing subtree renames
ldb.add({"dn": "cn=ldaptestcontainer," + self.base_dn,
"objectClass": "container"})
member: cn=ldaptestuser2,cn=users,""" + self.base_dn + """
""")
- print "Testing ldb.rename of cn=ldaptestcontainer," + self.base_dn + " to cn=ldaptestcontainer2," + self.base_dn
+ # Testing ldb.rename of cn=ldaptestcontainer," + self.base_dn + " to cn=ldaptestcontainer2," + self.base_dn
ldb.rename("CN=ldaptestcontainer," + self.base_dn, "CN=ldaptestcontainer2," + self.base_dn)
- print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))
res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))")
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))")
- print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
+ # Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
try:
res = ldb.search("cn=ldaptestcontainer," + 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)
- print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
+ # Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
try:
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)
- print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
+ # Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + self.base_dn)
time.sleep(4)
- print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
+ # Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE)
self.assertEquals(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not consistant with subtree renames?")
- print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn
+ # Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn
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)
- print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn
+ # 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))
- print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn
+ # 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)
- print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
+ # Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
self.assertEquals(len(res), 1)
res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
self.assertEquals(len(res), 0)
- print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
+ # Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_ONELEVEL)
self.assertEquals(len(res), 1)
- print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
+ # Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_SUBTREE)
self.assertEquals(len(res), 1)
- print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)
+ # Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)
ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
- print "Testing delete of renamed cn=ldaptestcontainer2," + self.base_dn
+ # Testing delete of renamed cn=ldaptestcontainer2," + self.base_dn
ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
ldb.add({"dn": "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
- print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))")
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
self.assertEquals(len(res[0]["memberOf"]), 1)
- print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn()
+ # Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn()
res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn())
self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn())
self.assertEquals(res[0].dn, res2[0].dn)
- print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
+ # Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched %d" % len(res3))
self.assertEquals(res[0].dn, res3[0].dn)
if gc_ldb is not None:
- print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
+ # Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
self.assertEquals(len(res3gc), 1)
self.assertEquals(res[0].dn, res3gc[0].dn)
- print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
+ # Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
if gc_ldb is not None:
res3control = gc_ldb.search(self.base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
ldb.delete(res[0].dn)
- print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))")
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
self.assertEquals(len(res[0]["memberOf"]), 1)
- print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn()
+ # Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn()
res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn())
self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn())
self.assertEquals(res[0].dn, res2[0].dn)
if gc_ldb is not None:
- print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s)) in Global Catalog" % gc_ldb.get_schema_basedn()
+ # Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s)) in Global Catalog" % gc_ldb.get_schema_basedn()
res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % gc_ldb.get_schema_basedn())
self.assertEquals(len(res2gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s)) In Global Catalog" % gc_ldb.get_schema_basedn())
self.assertEquals(res[0].dn, res2gc[0].dn)
- print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
+ # Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))")
self.assertEquals(res[0].dn, res3[0].dn)
if gc_ldb is not None:
- print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
+ # Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
self.assertEquals(len(res3gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog")
self.assertEquals(res[0].dn, res3gc[0].dn)
- print "Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
+ # Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
self.assertEquals(len(res4), 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
self.assertEquals(res[0].dn, res4[0].dn)
- print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
+ # Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))")
self.assertEquals(len(res5), 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))")
self.assertEquals(res[0].dn, res5[0].dn)
- print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
+ # Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))")
self.assertEquals(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))")
ldb.delete("<GUID=" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + ">")
- print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))")
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))")
ldb.delete("<SID=" + ldb.schema_format_value("objectSID", res[0]["objectSID"][0]) + ">")
attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "memberOf", "allowedAttributes", "allowedAttributesEffective"]
- print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
ldaptestuser2_guid = res_user[0]["objectGUID"][0]
attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "member", "allowedAttributes", "allowedAttributesEffective"]
- print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
+ # Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs, controls=["extended_dn:1:1"])
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
- print res[0]["member"]
+ print(res[0]["member"])
memberUP = []
for m in res[0]["member"]:
memberUP.append(m.upper())
- print ("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper()
+ print(("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper())
self.assertTrue(("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
- print "Quicktest for linked attributes"
+ # Quicktest for linked attributes"
ldb.modify_ldif("""
dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
changetype: modify
time.sleep(4)
attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
- print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
+ # Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete")
self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
self.assertTrue("member" not in res[0])
- print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
res = ldb.search(expression="(&(cn=ldaptestutf8user èùéìòà)(objectclass=user))")
# delete "ldaptestutf8user"
ldb.delete(res[0].dn)
- print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))")
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))")
- print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
+ # Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))")
self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))")
ldb.delete(("CN=ldaptestgroup2,CN=Users," + self.base_dn))
- print "Testing that we can't get at the configuration DN from the main search base"
+ # Testing that we can't get at the configuration DN from the main search base"
res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertEquals(len(res), 0)
- print "Testing that we can get at the configuration DN from the main search base on the LDAP port with the 'phantom root' search_options control"
+ # Testing that we can get at the configuration DN from the main search base on the LDAP port with the 'phantom root' search_options control"
res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
self.assertTrue(len(res) > 0)
if gc_ldb is not None:
- print "Testing that we can get at the configuration DN from the main search base on the GC port with the search_options control == 0"
+ # Testing that we can get at the configuration DN from the main search base on the GC port with the search_options control == 0"
res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"])
self.assertTrue(len(res) > 0)
- print "Testing that we do find configuration elements in the global catlog"
+ # Testing that we do find configuration elements in the global catlog"
res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertTrue(len(res) > 0)
- print "Testing that we do find configuration elements and user elements at the same time"
+ # Testing that we do find configuration elements and user elements at the same time"
res = gc_ldb.search(self.base_dn, expression="(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertTrue(len(res) > 0)
- print "Testing that we do find configuration elements in the global catlog, with the configuration basedn"
+ # Testing that we do find configuration elements in the global catlog, with the configuration basedn"
res = gc_ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertTrue(len(res) > 0)
- print "Testing that we can get at the configuration DN on the main LDAP port"
+ # Testing that we can get at the configuration DN on the main LDAP port"
res = ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertTrue(len(res) > 0)
- print "Testing objectCategory canonacolisation"
+ # Testing objectCategory canonacolisation"
res = ldb.search(self.configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA")
self.assertTrue(len(res) != 0)
self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + self.schema_dn)
self.assertTrue(len(res) != 0)
- print "Testing objectClass attribute order on "+ self.base_dn
+ # Testing objectClass attribute order on "+ self.base_dn
res = ldb.search(expression="objectClass=domain", base=self.base_dn,
scope=SCOPE_BASE, attrs=["objectClass"])
self.assertEquals(len(res), 1)
# check enumeration
- print "Testing ldb.search for objectCategory=person"
+ # Testing ldb.search for objectCategory=person"
res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertTrue(len(res) > 0)
- print "Testing ldb.search for objectCategory=person with domain scope control"
+ # Testing ldb.search for objectCategory=person with domain scope control"
res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
self.assertTrue(len(res) > 0)
- print "Testing ldb.search for objectCategory=user"
+ # Testing ldb.search for objectCategory=user"
res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertTrue(len(res) > 0)
- print "Testing ldb.search for objectCategory=user with domain scope control"
+ # Testing ldb.search for objectCategory=user with domain scope control"
res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
self.assertTrue(len(res) > 0)
- print "Testing ldb.search for objectCategory=group"
+ # Testing ldb.search for objectCategory=group"
res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"])
self.assertTrue(len(res) > 0)
- print "Testing ldb.search for objectCategory=group with domain scope control"
+ # Testing ldb.search for objectCategory=group with domain scope control"
res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
self.assertTrue(len(res) > 0)
- print "Testing creating a user with the posixAccount objectClass"
+ # Testing creating a user with the posixAccount objectClass"
self.ldb.add_ldif("""dn: cn=posixuser,CN=Users,%s
objectClass: top
objectClass: person
gecos: Posix User;;;
description: A POSIX user"""% (self.base_dn))
- print "Testing removing the posixAccount objectClass from an existing user"
+ # Testing removing the posixAccount objectClass from an existing user"
self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
changetype: modify
delete: objectClass
objectClass: posixAccount"""% (self.base_dn))
- print "Testing adding the posixAccount objectClass to an existing user"
+ # Testing adding the posixAccount objectClass to an existing user"
self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
changetype: modify
add: objectClass
"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)
sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
desc = security.descriptor.from_sddl(sddl, self.domain_sid)
desc_binary = ndr_pack(desc)
- desc_base64 = base64.b64encode(desc_binary)
+ desc_base64 = base64.b64encode(desc_binary).decode('utf8')
self.ldb.add_ldif("""
dn: """ + user_dn + """
objectclass: user
user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
delete_force(self.ldb, user_dn)
try:
- sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
+ sddl = "O:DUG:DUD:AI(A;;RPWP;;;AU)S:PAI"
desc = security.descriptor.from_sddl(sddl, security.dom_sid('S-1-5-21'))
- desc_base64 = base64.b64encode( ndr_pack(desc) )
+ desc_base64 = base64.b64encode( ndr_pack(desc) ).decode('utf8')
self.ldb.add_ldif("""
dn: """ + user_dn + """
objectclass: user
nTSecurityDescriptor:: """ + desc_base64)
res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
self.assertTrue("nTSecurityDescriptor" in res[0])
+ desc = res[0]["nTSecurityDescriptor"][0]
+ desc = ndr_unpack(security.descriptor, desc)
+ desc_sddl = desc.as_sddl(self.domain_sid)
+ self.assertTrue("O:S-1-5-21-513G:S-1-5-21-513D:AI(A;;RPWP;;;AU)" in desc_sddl)
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)
desc_sddl = desc.as_sddl(self.domain_sid)
sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
desc = security.descriptor.from_sddl(sddl, self.domain_sid)
- desc_base64 = base64.b64encode(ndr_pack(desc))
+ desc_base64 = base64.b64encode(ndr_pack(desc)).decode('utf8')
mod = """
dn: """ + user_dn + """
changetype: modify
# Modify descriptor
sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
desc = security.descriptor.from_sddl(sddl, self.domain_sid)
- desc_base64 = base64.b64encode(ndr_pack(desc))
+ desc_base64 = base64.b64encode(ndr_pack(desc)).decode('utf8')
mod = """
dn: """ + user_dn + """
changetype: modify
def test_dsheuristics(self):
"""Tests the 'dSHeuristics' attribute"""
- print "Tests the 'dSHeuristics' attribute"""
+ # Tests the 'dSHeuristics' attribute"
# Get the current value to restore it later
dsheuristics = self.ldb.get_dsheuristics()
- # Should not be longer than 18 chars?
- try:
- self.ldb.set_dsheuristics("123ABC-+!1asdfg@#^12")
- except LdbError, (num, _):
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
- # If it is >= 10 chars, tenthChar should be 1
- try:
- self.ldb.set_dsheuristics("00020000000002")
- except LdbError, (num, _):
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
- # apart from the above, all char values are accepted
- self.ldb.set_dsheuristics("123ABC-+!1asdfg@#^")
- self.assertEquals(self.ldb.get_dsheuristics(), "123ABC-+!1asdfg@#^")
- # restore old value
- self.ldb.set_dsheuristics(dsheuristics)
+ # Perform the length checks: for each decade (except the 0th) we need
+ # the first index to be the number. This goes till the 9th one, beyond
+ # there does not seem to be another limitation.
+ try:
+ dshstr = ""
+ for i in range(1,11):
+ # This is in the range
+ self.ldb.set_dsheuristics(dshstr + "x")
+ self.ldb.set_dsheuristics(dshstr + "xxxxx")
+ dshstr = dshstr + "xxxxxxxxx"
+ if i < 10:
+ # Not anymore in the range, new decade specifier needed
+ try:
+ self.ldb.set_dsheuristics(dshstr + "x")
+ self.fail()
+ except LdbError as e:
+ (num, _) = e.args
+ self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ dshstr = dshstr + str(i)
+ else:
+ # There does not seem to be an upper limit
+ self.ldb.set_dsheuristics(dshstr + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
+ # apart from the above, all char values are accepted
+ self.ldb.set_dsheuristics("123ABC-+!1asdfg@#^")
+ self.assertEquals(self.ldb.get_dsheuristics(), "123ABC-+!1asdfg@#^")
+ finally:
+ # restore old value
+ self.ldb.set_dsheuristics(dsheuristics)
def test_ldapControlReturn(self):
"""Testing that if we request a control that return a control it
def test_operational(self):
"""Tests operational attributes"""
- print "Tests operational attributes"""
+ # Tests operational attributes"
res = self.ldb.search(self.base_dn, scope=SCOPE_BASE,
attrs=["createTimeStamp", "modifyTimeStamp",
self.assertTrue("whenCreated" in res[0])
self.assertTrue("whenChanged" in res[0])
-class BaseDnTests(unittest.TestCase):
+ def test_timevalues1(self):
+ """Tests possible syntax of time attributes"""
+
+ user_name = "testtimevaluesuser1"
+ user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
+
+ delete_force(self.ldb, user_dn)
+ self.ldb.add({ "dn": user_dn,
+ "objectClass": "user",
+ "sAMAccountName": user_name })
+
+ #
+ # We check the following values:
+ #
+ # 370101000000Z => 20370101000000.0Z
+ # 20370102000000.*Z => 20370102000000.0Z
+ #
+ ext = [ "Z", ".0Z", ".Z", ".000Z", ".RandomIgnoredCharacters...987654321Z" ]
+ for i in range(0, len(ext)):
+ v_raw = "203701%02d000000" % (i + 1)
+ if ext[i] == "Z":
+ v_set = v_raw[2:] + ext[i]
+ else:
+ v_set = v_raw + ext[i]
+ v_get = v_raw + ".0Z"
+
+ m = Message()
+ m.dn = Dn(ldb, user_dn)
+ m["msTSExpireDate"] = MessageElement([v_set],
+ FLAG_MOD_REPLACE,
+ "msTSExpireDate")
+ self.ldb.modify(m)
+
+ res = self.ldb.search(base=user_dn, scope=SCOPE_BASE, attrs=["msTSExpireDate"])
+ self.assertTrue(len(res) == 1)
+ self.assertTrue("msTSExpireDate" in res[0])
+ self.assertTrue(len(res[0]["msTSExpireDate"]) == 1)
+ self.assertEquals(res[0]["msTSExpireDate"][0], v_get)
+
+class BaseDnTests(samba.tests.TestCase):
def setUp(self):
super(BaseDnTests, self).setUp()
def test_ldapServiceName(self):
"""Testing the ldap service name in rootDSE"""
res = self.ldb.search("", scope=SCOPE_BASE,
- attrs=["ldapServiceName", "dNSHostName"])
+ attrs=["ldapServiceName", "dnsHostName"])
self.assertEquals(len(res), 1)
+ self.assertTrue("ldapServiceName" in res[0])
+ self.assertTrue("dnsHostName" in res[0])
+
+ (hostname, _, dns_domainname) = res[0]["dnsHostName"][0].partition(".")
- (hostname, _, dns_domainname) = res[0]["dNSHostName"][0].partition(".")
- self.assertTrue(":%s$@%s" % (hostname, dns_domainname.upper())
- in res[0]["ldapServiceName"][0])
+ given = res[0]["ldapServiceName"][0]
+ expected = "%s:%s$@%s" % (dns_domainname.lower(), hostname.lower(), dns_domainname.upper())
+ self.assertEquals(given, expected)
if not "://" in host:
if os.path.isfile(host):
else:
gc_ldb = None
-runner = SubunitTestRunner()
-rc = 0
-if not runner.run(unittest.makeSuite(BaseDnTests)).wasSuccessful():
- rc = 1
-if not runner.run(unittest.makeSuite(BasicTests)).wasSuccessful():
- rc = 1
-sys.exit(rc)
+TestProgram(module=__name__, opts=subunitopts)
git.samba.org / samba.git / blobdiff