mirror of
https://salsa.debian.org/freeipa-team/freeipa.git
synced 2025-02-25 18:55:28 -06:00
1328f984d0
Because the attrs & values in DN's, RDN's and AVA's are comparison case-
insensitive the hash value between two objects which compare as equal but
differ in case must also yield the same hash value. This is critical when
these objects are used as a dict key or in a set because dicts and sets
use the object's __hash__ value in conjunction with the objects __eq__
method to lookup the object.
The defect is the DN, RDN & AVA objects computed their hash from the case-
preserving string representation thus two otherwise equal objects
incorrectly yielded different hash values.
The problem manifests itself when one of these objects is used as a key in
a dict, for example a dn.
dn1 = DN(('cn', 'Bob'))
dn2 = DN(('cn', 'bob'))
dn1 == dn2 --> True
hash(dn1) == hash(dn2) --> False
d = {}
d[dn1] = x
d[dn2] = y
len(d) --> 2
The patch fixes the above by lower casing the string representation of
the object prior to computing it's hash.
The patch also corrects a spelling mistake and a bogus return value in
ldapupdate.py which happened to be discovered while researching this
bug.
1938 lines
78 KiB
Python
1938 lines
78 KiB
Python
#!/usr/bin/python
|
|
|
|
import unittest
|
|
from ipapython.dn import *
|
|
|
|
def default_rdn_attr_arg(i):
|
|
return 'a%d' % i
|
|
|
|
def default_rdn_value_arg(i):
|
|
return str(i)
|
|
|
|
def alt_rdn_attr_arg(i):
|
|
return 'b%d' % i
|
|
|
|
def alt_rdn_value_arg(i):
|
|
return str(i*10)
|
|
|
|
def make_rdn_args(low, high, kind, attr=None, value=None):
|
|
result=[]
|
|
for i in range(low, high):
|
|
if attr is None:
|
|
new_attr = default_rdn_attr_arg(i)
|
|
elif callable(attr):
|
|
new_attr = attr(i)
|
|
else:
|
|
new_attr = attr
|
|
|
|
if value is None:
|
|
new_value = default_rdn_value_arg(i)
|
|
elif callable(value):
|
|
new_value = value(i)
|
|
else:
|
|
new_value = value
|
|
|
|
if kind == 'tuple':
|
|
result.append((new_attr, new_value))
|
|
elif kind == 'list':
|
|
result.append([new_attr, new_value])
|
|
elif kind == 'RDN':
|
|
result.append(RDN((new_attr, new_value)))
|
|
else:
|
|
raise ValueError("Unknown kind = %s" % kind)
|
|
|
|
return result
|
|
|
|
def expected_class(klass, component):
|
|
if klass is AVA:
|
|
if component == 'self':
|
|
return AVA
|
|
|
|
elif klass is EditableAVA:
|
|
if component == 'self':
|
|
return EditableAVA
|
|
|
|
elif klass is RDN:
|
|
if component == 'self':
|
|
return RDN
|
|
elif component == 'AVA':
|
|
return AVA
|
|
|
|
elif klass is EditableRDN:
|
|
if component == 'self':
|
|
return EditableRDN
|
|
elif component == 'AVA':
|
|
return EditableAVA
|
|
|
|
elif klass is DN:
|
|
if component == 'self':
|
|
return DN
|
|
elif component == 'AVA':
|
|
return AVA
|
|
elif component == 'RDN':
|
|
return RDN
|
|
|
|
elif klass is EditableDN:
|
|
if component == 'self':
|
|
return EditableDN
|
|
elif component == 'AVA':
|
|
return EditableAVA
|
|
elif component == 'RDN':
|
|
return EditableRDN
|
|
|
|
raise ValueError("class %s with component '%s' unknown" % (klass.__name__, component))
|
|
|
|
|
|
class TestAVA(unittest.TestCase):
|
|
def setUp(self):
|
|
self.attr1 = 'cn'
|
|
self.value1 = 'Bob'
|
|
self.str_ava1 = '%s=%s' % (self.attr1, self.value1)
|
|
self.ava1 = AVA(self.attr1, self.value1)
|
|
|
|
self.attr2 = 'ou'
|
|
self.value2 = 'People'
|
|
self.str_ava2 = '%s=%s' % (self.attr2, self.value2)
|
|
self.ava2 = AVA(self.attr2, self.value2)
|
|
|
|
self.attr3 = 'c'
|
|
self.value3 = 'US'
|
|
self.str_ava3 = '%s=%s' % (self.attr3, self.value3)
|
|
self.ava3 = AVA(self.attr3, self.value3)
|
|
|
|
def assertExpectedClass(self, klass, obj, component):
|
|
self.assertIs(obj.__class__, expected_class(klass, component))
|
|
|
|
def test_create(self):
|
|
for AVA_class in (AVA, EditableAVA):
|
|
# Create with attr,value pair
|
|
ava1 = AVA_class(self.attr1, self.value1)
|
|
self.assertExpectedClass(AVA_class, ava1, 'self')
|
|
self.assertEqual(ava1, self.ava1)
|
|
|
|
# Create with "attr=value" string
|
|
ava1 = AVA_class(self.str_ava1)
|
|
self.assertExpectedClass(AVA_class, ava1, 'self')
|
|
self.assertEqual(ava1, self.ava1)
|
|
|
|
# Create with tuple (attr, value)
|
|
ava1 = AVA_class((self.attr1, self.value1))
|
|
self.assertExpectedClass(AVA_class, ava1, 'self')
|
|
self.assertEqual(ava1, self.ava1)
|
|
|
|
# Create with list [attr, value]
|
|
ava1 = AVA_class([self.attr1, self.value1])
|
|
self.assertExpectedClass(AVA_class, ava1, 'self')
|
|
self.assertEqual(ava1, self.ava1)
|
|
|
|
# Create with no args should fail
|
|
with self.assertRaises(TypeError):
|
|
AVA_class()
|
|
|
|
# Create with more than 2 args should fail
|
|
with self.assertRaises(TypeError):
|
|
AVA_class(self.attr1, self.value1, self.attr1)
|
|
|
|
# Create with 1 arg which is not string should fail
|
|
with self.assertRaises(TypeError):
|
|
AVA_class(1)
|
|
|
|
# Create with malformed AVA_class string should fail
|
|
with self.assertRaises(ValueError):
|
|
AVA_class("cn")
|
|
|
|
# Create with non-string parameters, should convert
|
|
ava1 = AVA_class(1, self.value1)
|
|
self.assertExpectedClass(AVA_class, ava1, 'self')
|
|
self.assertEqual(ava1.attr, u'1')
|
|
|
|
ava1 = AVA_class((1, self.value1))
|
|
self.assertExpectedClass(AVA_class, ava1, 'self')
|
|
self.assertEqual(ava1.attr, u'1')
|
|
|
|
ava1 = AVA_class(self.attr1, 1)
|
|
self.assertExpectedClass(AVA_class, ava1, 'self')
|
|
self.assertEqual(ava1.value, u'1')
|
|
|
|
ava1 = AVA_class((self.attr1, 1))
|
|
self.assertExpectedClass(AVA_class, ava1, 'self')
|
|
self.assertEqual(ava1.value, u'1')
|
|
|
|
def test_indexing(self):
|
|
for AVA_class in (AVA, EditableAVA):
|
|
ava1 = AVA_class(self.ava1)
|
|
|
|
self.assertEqual(ava1[self.attr1], self.value1)
|
|
|
|
with self.assertRaises(KeyError):
|
|
ava1['foo']
|
|
|
|
with self.assertRaises(TypeError):
|
|
ava1[0]
|
|
|
|
def test_properties(self):
|
|
for AVA_class in (AVA, EditableAVA):
|
|
ava1 = AVA_class(self.ava1)
|
|
|
|
self.assertEqual(ava1.attr, self.attr1)
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
|
|
self.assertEqual(ava1.value, self.value1)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
|
|
def test_str(self):
|
|
for AVA_class in (AVA, EditableAVA):
|
|
ava1 = AVA_class(self.ava1)
|
|
|
|
self.assertEqual(str(ava1), self.str_ava1)
|
|
self.assertIsInstance(str(ava1), str)
|
|
|
|
def test_cmp(self):
|
|
for AVA_class in (AVA, EditableAVA):
|
|
# Equality
|
|
ava1 = AVA_class(self.attr1, self.value1)
|
|
|
|
self.assertTrue(ava1 == self.ava1)
|
|
self.assertFalse(ava1 != self.ava1)
|
|
|
|
self.assertTrue(ava1 == self.str_ava1)
|
|
self.assertFalse(ava1 != self.str_ava1)
|
|
|
|
result = cmp(ava1, self.ava1)
|
|
self.assertEqual(result, 0)
|
|
|
|
# Upper case attr should still be equal
|
|
ava1 = AVA_class(self.attr1.upper(), self.value1)
|
|
|
|
self.assertFalse(ava1.attr == self.attr1)
|
|
self.assertTrue(ava1.value == self.value1)
|
|
self.assertTrue(ava1 == self.ava1)
|
|
self.assertFalse(ava1 != self.ava1)
|
|
|
|
result = cmp(ava1, self.ava1)
|
|
self.assertEqual(result, 0)
|
|
|
|
# Upper case value should still be equal
|
|
ava1 = AVA_class(self.attr1, self.value1.upper())
|
|
|
|
self.assertTrue(ava1.attr == self.attr1)
|
|
self.assertFalse(ava1.value == self.value1)
|
|
self.assertTrue(ava1 == self.ava1)
|
|
self.assertFalse(ava1 != self.ava1)
|
|
|
|
result = cmp(ava1, self.ava1)
|
|
self.assertEqual(result, 0)
|
|
|
|
# Make ava1's attr greater
|
|
if AVA_class.is_mutable:
|
|
ava1.attr = self.attr1 + "1"
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
ava1.attr = self.attr1 + "1"
|
|
ava1 = AVA_class(self.attr1 + "1", self.value1.upper())
|
|
|
|
self.assertFalse(ava1 == self.ava1)
|
|
self.assertTrue(ava1 != self.ava1)
|
|
|
|
result = cmp(ava1, self.ava1)
|
|
self.assertEqual(result, 1)
|
|
|
|
result = cmp(self.ava1, ava1)
|
|
self.assertEqual(result, -1)
|
|
|
|
# Reset ava1's attr, should be equal again
|
|
if AVA_class.is_mutable:
|
|
ava1.attr = self.attr1
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
ava1.attr = self.attr1
|
|
ava1 = AVA_class(self.attr1, self.value1.upper())
|
|
|
|
result = cmp(ava1, self.ava1)
|
|
self.assertEqual(result, 0)
|
|
|
|
# Make ava1's value greater
|
|
# attr will be equal, this tests secondary comparision component
|
|
if AVA_class.is_mutable:
|
|
ava1.value = self.value1 + "1"
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
ava1.value = self.value1 + "1"
|
|
ava1 = AVA_class(self.attr1, self.value1 + "1")
|
|
|
|
result = cmp(ava1, self.ava1)
|
|
self.assertEqual(result, 1)
|
|
|
|
result = cmp(self.ava1, ava1)
|
|
self.assertEqual(result, -1)
|
|
|
|
def test_hashing(self):
|
|
# create AVA's that are equal but differ in case
|
|
immutable_ava1 = AVA((self.attr1.lower(), self.value1.upper()))
|
|
immutable_ava2 = AVA((self.attr1.upper(), self.value1.lower()))
|
|
|
|
mutable_ava1 = EditableAVA((self.attr1.lower(), self.value1.upper()))
|
|
mutable_ava2 = EditableAVA((self.attr1.upper(), self.value1.lower()))
|
|
|
|
# Immutable AVA's that are equal should hash to the same value.
|
|
# Mutable AVA's should not be hashable.
|
|
|
|
self.assertEqual(immutable_ava1, immutable_ava2)
|
|
self.assertEqual(immutable_ava1, mutable_ava1)
|
|
self.assertEqual(immutable_ava1, mutable_ava2)
|
|
self.assertEqual(mutable_ava1, immutable_ava2)
|
|
|
|
# Good, everyone's equal, now verify their hash values
|
|
|
|
self.assertEqual(hash(immutable_ava1), hash(immutable_ava2))
|
|
with self.assertRaises(TypeError):
|
|
hash(mutable_ava1)
|
|
with self.assertRaises(TypeError):
|
|
hash(mutable_ava2)
|
|
|
|
# Different immutable AVA objects with the same value should
|
|
# map to 1 common key and 1 member in a set. The key and
|
|
# member are based on the object's value.
|
|
#
|
|
# Mutable AVA objects should be unhashable.
|
|
|
|
for AVA_class in (AVA, EditableAVA):
|
|
ava1_a = AVA_class(self.ava1)
|
|
ava1_b = AVA_class(self.ava1)
|
|
|
|
ava2_a = AVA_class(self.ava2)
|
|
ava2_b = AVA_class(self.ava2)
|
|
|
|
ava3_a = AVA_class(self.ava3)
|
|
ava3_b = AVA_class(self.ava3)
|
|
|
|
self.assertEqual(ava1_a, ava1_b)
|
|
self.assertEqual(ava2_a, ava2_b)
|
|
self.assertEqual(ava3_a, ava3_b)
|
|
|
|
d = dict()
|
|
s = set()
|
|
|
|
if AVA_class.is_mutable:
|
|
with self.assertRaises(TypeError):
|
|
d[ava1_a] = str(ava1_a)
|
|
with self.assertRaises(TypeError):
|
|
d[ava1_b] = str(ava1_b)
|
|
with self.assertRaises(TypeError):
|
|
d[ava2_a] = str(ava2_a)
|
|
with self.assertRaises(TypeError):
|
|
d[ava2_b] = str(ava2_b)
|
|
|
|
with self.assertRaises(TypeError):
|
|
s.add(ava1_a)
|
|
with self.assertRaises(TypeError):
|
|
s.add(ava1_b)
|
|
with self.assertRaises(TypeError):
|
|
s.add(ava2_a)
|
|
with self.assertRaises(TypeError):
|
|
s.add(ava2_b)
|
|
else:
|
|
d[ava1_a] = str(ava1_a)
|
|
d[ava1_b] = str(ava1_b)
|
|
d[ava2_a] = str(ava2_a)
|
|
d[ava2_b] = str(ava2_b)
|
|
|
|
s.add(ava1_a)
|
|
s.add(ava1_b)
|
|
s.add(ava2_a)
|
|
s.add(ava2_b)
|
|
|
|
self.assertEqual(len(d), 2)
|
|
self.assertEqual(len(s), 2)
|
|
self.assertEqual(sorted(d.keys()), sorted([ava1_a, ava2_a]))
|
|
self.assertEqual(sorted(s), sorted([ava1_a, ava2_a]))
|
|
|
|
self.assertTrue(ava1_a in d)
|
|
self.assertTrue(ava1_b in d)
|
|
self.assertTrue(ava2_a in d)
|
|
self.assertTrue(ava2_b in d)
|
|
self.assertFalse(ava3_a in d)
|
|
self.assertFalse(ava3_b in d)
|
|
|
|
self.assertTrue(d.has_key(ava1_a))
|
|
self.assertTrue(d.has_key(ava1_b))
|
|
self.assertTrue(d.has_key(ava2_a))
|
|
self.assertTrue(d.has_key(ava2_b))
|
|
self.assertFalse(d.has_key(ava3_a))
|
|
self.assertFalse(d.has_key(ava3_b))
|
|
|
|
self.assertTrue(ava1_a in s)
|
|
self.assertTrue(ava1_b in s)
|
|
self.assertTrue(ava2_a in s)
|
|
self.assertTrue(ava2_b in s)
|
|
self.assertFalse(ava3_a in s)
|
|
self.assertFalse(ava3_b in s)
|
|
|
|
def test_coerce(self):
|
|
# Coerce an immutable to a mutable
|
|
immutable_ava1 = AVA(self.ava1)
|
|
mutable_ava1 = EditableAVA(immutable_ava1)
|
|
self.assertEqual(mutable_ava1, self.ava1)
|
|
self.assertEqual(mutable_ava1, immutable_ava1)
|
|
|
|
# Coerce a mutable to an immutable
|
|
mutable_ava1 = EditableAVA(self.ava1)
|
|
immutable_ava1 = AVA(mutable_ava1)
|
|
self.assertEqual(immutable_ava1, self.ava1)
|
|
self.assertEqual(immutable_ava1, mutable_ava1)
|
|
|
|
class TestRDN(unittest.TestCase):
|
|
def setUp(self):
|
|
# ava1 must sort before ava2
|
|
self.attr1 = 'cn'
|
|
self.value1 = 'Bob'
|
|
self.str_ava1 = '%s=%s' % (self.attr1, self.value1)
|
|
self.ava1 = AVA(self.attr1, self.value1)
|
|
|
|
self.str_rdn1 = '%s=%s' % (self.attr1, self.value1)
|
|
self.rdn1 = RDN((self.attr1, self.value1))
|
|
|
|
self.attr2 = 'ou'
|
|
self.value2 = 'people'
|
|
self.str_ava2 = '%s=%s' % (self.attr2, self.value2)
|
|
self.ava2 = AVA(self.attr2, self.value2)
|
|
|
|
self.str_rdn2 = '%s=%s' % (self.attr2, self.value2)
|
|
self.rdn2 = RDN((self.attr2, self.value2))
|
|
|
|
self.str_ava3 = '%s=%s+%s=%s' % (self.attr1, self.value1, self.attr2, self.value2)
|
|
|
|
self.str_rdn3 = '%s=%s+%s=%s' % (self.attr1, self.value1, self.attr2, self.value2)
|
|
self.rdn3 = RDN(self.ava1, self.ava2)
|
|
|
|
def assertExpectedClass(self, klass, obj, component):
|
|
self.assertIs(obj.__class__, expected_class(klass, component))
|
|
|
|
def test_create(self):
|
|
for RDN_class in (RDN, EditableRDN):
|
|
# Create with single attr,value pair
|
|
rdn1 = RDN_class((self.attr1, self.value1))
|
|
|
|
|
|
self.assertEqual(len(rdn1), 1)
|
|
self.assertEqual(rdn1, self.rdn1)
|
|
self.assertExpectedClass(RDN_class, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN_class, rdn1[i], 'AVA')
|
|
self.assertEqual(rdn1[0], self.ava1)
|
|
|
|
# Create with multiple attr,value pairs
|
|
rdn3 = RDN_class((self.attr1, self.value1), (self.attr2, self.value2))
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
self.assertEqual(rdn3[1], self.ava2)
|
|
|
|
# Create with multiple attr,value pairs passed as lists
|
|
rdn3 = RDN_class([self.attr1, self.value1], [self.attr2, self.value2])
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
self.assertEqual(rdn3[1], self.ava2)
|
|
|
|
# Create with multiple attr,value pairs but reverse
|
|
# constructor parameter ordering. RDN canonical ordering
|
|
# should remain the same
|
|
rdn3 = RDN_class((self.attr2, self.value2), (self.attr1, self.value1))
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
self.assertEqual(rdn3[1], self.ava2)
|
|
|
|
# Create with single AVA object
|
|
rdn1 = RDN_class(self.ava1)
|
|
self.assertEqual(len(rdn1), 1)
|
|
self.assertEqual(rdn1, self.rdn1)
|
|
self.assertExpectedClass(RDN_class, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN_class, rdn1[i], 'AVA')
|
|
self.assertEqual(rdn1[0], self.ava1)
|
|
|
|
# Create with multiple AVA objects
|
|
rdn3 = RDN_class(self.ava1, self.ava2)
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
self.assertEqual(rdn3[1], self.ava2)
|
|
|
|
|
|
# Create with multiple AVA objects but reverse constructor
|
|
# parameter ordering. RDN canonical ordering should remain
|
|
# the same
|
|
rdn3 = RDN_class(self.ava2, self.ava1)
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
self.assertEqual(rdn3[1], self.ava2)
|
|
|
|
# Create with single string with 1 AVA
|
|
rdn1 = RDN_class(self.str_rdn1)
|
|
self.assertEqual(len(rdn1), 1)
|
|
self.assertEqual(rdn1, self.rdn1)
|
|
self.assertExpectedClass(RDN_class, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN_class, rdn1[i], 'AVA')
|
|
self.assertEqual(rdn1[0], self.ava1)
|
|
|
|
# Create with single string with 2 AVA's
|
|
rdn3 = RDN_class(self.str_rdn3)
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
self.assertEqual(rdn3[1], self.ava2)
|
|
|
|
def test_properties(self):
|
|
for RDN_class in (RDN, EditableRDN):
|
|
rdn1 = RDN_class(self.rdn1)
|
|
rdn2 = RDN_class(self.rdn2)
|
|
rdn3 = RDN_class(self.rdn3)
|
|
|
|
self.assertEqual(rdn1.attr, self.attr1)
|
|
self.assertIsInstance(rdn1.attr, unicode)
|
|
|
|
self.assertEqual(rdn1.value, self.value1)
|
|
self.assertIsInstance(rdn1.value, unicode)
|
|
|
|
self.assertEqual(rdn2.attr, self.attr2)
|
|
self.assertIsInstance(rdn2.attr, unicode)
|
|
|
|
self.assertEqual(rdn2.value, self.value2)
|
|
self.assertIsInstance(rdn2.value, unicode)
|
|
|
|
self.assertEqual(rdn3.attr, self.attr1)
|
|
self.assertIsInstance(rdn3.attr, unicode)
|
|
|
|
self.assertEqual(rdn3.value, self.value1)
|
|
self.assertIsInstance(rdn3.value, unicode)
|
|
|
|
def test_str(self):
|
|
for RDN_class in (RDN, EditableRDN):
|
|
rdn1 = RDN_class(self.rdn1)
|
|
rdn2 = RDN_class(self.rdn2)
|
|
rdn3 = RDN_class(self.rdn3)
|
|
|
|
self.assertEqual(str(rdn1), self.str_rdn1)
|
|
self.assertIsInstance(str(rdn1), str)
|
|
|
|
self.assertEqual(str(rdn2), self.str_rdn2)
|
|
self.assertIsInstance(str(rdn2), str)
|
|
|
|
self.assertEqual(str(rdn3), self.str_rdn3)
|
|
self.assertIsInstance(str(rdn3), str)
|
|
|
|
def test_cmp(self):
|
|
for RDN_class in (RDN, EditableRDN):
|
|
# Equality
|
|
rdn1 = RDN_class((self.attr1, self.value1))
|
|
|
|
self.assertTrue(rdn1 == self.rdn1)
|
|
self.assertFalse(rdn1 != self.rdn1)
|
|
|
|
self.assertTrue(rdn1 == self.str_rdn1)
|
|
self.assertFalse(rdn1 != self.str_rdn1)
|
|
|
|
result = cmp(rdn1, self.rdn1)
|
|
self.assertEqual(result, 0)
|
|
|
|
# Make rdn1's attr greater
|
|
if RDN_class.is_mutable:
|
|
rdn1.attr = self.attr1 + "1"
|
|
else:
|
|
rdn1 = RDN_class((self.attr1 + "1", self.value1))
|
|
|
|
self.assertFalse(rdn1 == self.rdn1)
|
|
self.assertTrue(rdn1 != self.rdn1)
|
|
|
|
result = cmp(rdn1, self.rdn1)
|
|
self.assertEqual(result, 1)
|
|
|
|
result = cmp(self.rdn1, rdn1)
|
|
self.assertEqual(result, -1)
|
|
|
|
# Reset rdn1's attr, should be equal again
|
|
if RDN_class.is_mutable:
|
|
rdn1.attr = self.attr1
|
|
else:
|
|
rdn1 = RDN_class((self.attr1, self.value1))
|
|
|
|
result = cmp(rdn1, self.rdn1)
|
|
self.assertEqual(result, 0)
|
|
|
|
# Make rdn1's value greater
|
|
# attr will be equal, this tests secondary comparision component
|
|
if RDN_class.is_mutable:
|
|
rdn1.value = self.value1 + "1"
|
|
else:
|
|
rdn1 = RDN_class((self.attr1, self.value1 + "1"))
|
|
|
|
result = cmp(rdn1, self.rdn1)
|
|
self.assertEqual(result, 1)
|
|
|
|
result = cmp(self.rdn1, rdn1)
|
|
self.assertEqual(result, -1)
|
|
|
|
# Make sure rdn's with more ava's are greater
|
|
result = cmp(self.rdn1, self.rdn3)
|
|
self.assertEqual(result, -1)
|
|
result = cmp(self.rdn3, self.rdn1)
|
|
self.assertEqual(result, 1)
|
|
|
|
def test_indexing(self):
|
|
for RDN_class in (RDN, EditableRDN):
|
|
rdn1 = RDN_class(self.rdn1)
|
|
rdn2 = RDN_class(self.rdn2)
|
|
rdn3 = RDN_class(self.rdn3)
|
|
|
|
self.assertEqual(rdn1[0], self.ava1)
|
|
self.assertEqual(rdn1[self.ava1.attr], self.ava1.value)
|
|
with self.assertRaises(KeyError):
|
|
rdn1['foo']
|
|
|
|
self.assertEqual(rdn2[0], self.ava2)
|
|
self.assertEqual(rdn2[self.ava2.attr], self.ava2.value)
|
|
with self.assertRaises(KeyError):
|
|
rdn2['foo']
|
|
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
self.assertEqual(rdn3[self.ava1.attr], self.ava1.value)
|
|
self.assertEqual(rdn3[1], self.ava2)
|
|
self.assertEqual(rdn3[self.ava2.attr], self.ava2.value)
|
|
with self.assertRaises(KeyError):
|
|
rdn3['foo']
|
|
|
|
self.assertEqual(rdn1.attr, self.attr1)
|
|
self.assertEqual(rdn1.value, self.value1)
|
|
|
|
with self.assertRaises(TypeError):
|
|
rdn3[1.0]
|
|
|
|
# Slices
|
|
self.assertEqual(rdn3[0:1], [self.ava1])
|
|
self.assertEqual(rdn3[:], [self.ava1, self.ava2])
|
|
|
|
def test_assignments(self):
|
|
for RDN_class in (RDN, EditableRDN):
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
if RDN_class.is_mutable:
|
|
rdn[0] = self.ava2
|
|
self.assertEqual(rdn, self.rdn2)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
rdn[0] = self.ava2
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
if RDN_class.is_mutable:
|
|
rdn[0] = (self.attr2, self.value2)
|
|
self.assertEqual(rdn, self.rdn2)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
rdn[0] = (self.attr2, self.value2)
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
if RDN_class.is_mutable:
|
|
rdn[self.attr1] = self.str_ava2
|
|
self.assertEqual(rdn[0], self.ava2)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
rdn[self.attr1] = self.str_ava2
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
# Can't assign multiples to single entry
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
with self.assertRaises(TypeError):
|
|
rdn[self.attr1] = self.str_ava3
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
with self.assertRaises(TypeError):
|
|
rdn[self.attr1] = (self.attr1, self.value1, self.attr2, self.value2)
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
with self.assertRaises(TypeError):
|
|
rdn[self.attr1] = [(self.attr1, self.value1), (self.attr2, self.value2)]
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
# Slices
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
self.assertEqual(rdn, self.rdn1)
|
|
if RDN_class.is_mutable:
|
|
rdn[0:1] = [self.ava2]
|
|
self.assertEqual(rdn, self.rdn2)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
rdn[0:1] = [self.ava2]
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
self.assertEqual(rdn, self.rdn1)
|
|
if RDN_class.is_mutable:
|
|
rdn[:] = [(self.attr2, self.value2)]
|
|
self.assertEqual(rdn, self.rdn2)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
rdn[:] = [(self.attr2, self.value2)]
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
self.assertEqual(rdn, self.rdn1)
|
|
if RDN_class.is_mutable:
|
|
rdn[:] = [(self.attr1, self.value1),(self.attr2, self.value2)]
|
|
self.assertEqual(rdn, self.rdn3)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
rdn[:] = [(self.attr1, self.value1),(self.attr2, self.value2)]
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
rdn = RDN_class((self.attr1, self.value1))
|
|
self.assertEqual(rdn, self.rdn1)
|
|
if RDN_class.is_mutable:
|
|
rdn[0:1] = [(self.attr1, self.value1), (self.attr2, self.value2)]
|
|
self.assertEqual(rdn, self.rdn3)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
rdn[0:1] = [(self.attr1, self.value1), (self.attr2, self.value2)]
|
|
self.assertExpectedClass(RDN_class, rdn, 'self')
|
|
for i in range(0, len(rdn)):
|
|
self.assertExpectedClass(RDN_class, rdn[i], 'AVA')
|
|
|
|
|
|
def test_iter(self):
|
|
for RDN_class in (RDN, EditableRDN):
|
|
rdn1 = RDN_class(self.rdn1)
|
|
rdn2 = RDN_class(self.rdn2)
|
|
rdn3 = RDN_class(self.rdn3)
|
|
|
|
self.assertEqual(len(rdn1), 1)
|
|
self.assertEqual(rdn1[:], [self.ava1])
|
|
for i, ava in enumerate(rdn1):
|
|
if i == 0:
|
|
self.assertEqual(ava, self.ava1)
|
|
else:
|
|
self.fail("got iteration index %d, but len=%d" % (i, len(rdn1)))
|
|
|
|
self.assertEqual(len(rdn2), 1)
|
|
self.assertEqual(rdn2[:], [self.ava2])
|
|
for i, ava in enumerate(rdn2):
|
|
if i == 0:
|
|
self.assertEqual(ava, self.ava2)
|
|
else:
|
|
self.fail("got iteration index %d, but len=%d" % (i, len(rdn2)))
|
|
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3[:], [self.ava1, self.ava2])
|
|
for i, ava in enumerate(rdn3):
|
|
if i == 0:
|
|
self.assertEqual(ava, self.ava1)
|
|
elif i == 1:
|
|
self.assertEqual(ava, self.ava2)
|
|
else:
|
|
self.fail("got iteration index %d, but len=%d" % (i, len(rdn3)))
|
|
|
|
|
|
def test_concat(self):
|
|
for RDN_class in (RDN, EditableRDN):
|
|
rdn1 = RDN_class((self.attr1, self.value1))
|
|
rdn2 = RDN_class((self.attr2, self.value2))
|
|
|
|
# in-place addtion
|
|
|
|
# Note: If __iadd__ is not available Python will emulate += by
|
|
# replacing the lhs object with the result of __add__ (if available).
|
|
# Thus += works for both immutable and mutable RDN,DN object, the only
|
|
# difference is an immutable without __iadd__ will have a different object
|
|
# on the lhs after the operator evaluates.
|
|
|
|
rdn1 += rdn2
|
|
self.assertEqual(rdn1, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN_class, rdn1[i], 'AVA')
|
|
|
|
rdn1 = RDN_class((self.attr1, self.value1))
|
|
rdn1 += self.ava2
|
|
self.assertEqual(rdn1, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN_class, rdn1[i], 'AVA')
|
|
|
|
rdn1 = RDN_class((self.attr1, self.value1))
|
|
rdn1 += self.str_ava2
|
|
self.assertEqual(rdn1, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN_class, rdn1[i], 'AVA')
|
|
|
|
# concatenation
|
|
rdn1 = RDN_class((self.attr1, self.value1))
|
|
rdn3 = rdn1 + rdn2
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
|
|
rdn3 = rdn1 + self.ava2
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
|
|
rdn3 = rdn1 + self.str_ava2
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN_class, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN_class, rdn3[i], 'AVA')
|
|
|
|
|
|
def test_hashing(self):
|
|
# create RDN's that are equal but differ in case
|
|
immutable_rdn1 = RDN((self.attr1.lower(), self.value1.upper()))
|
|
immutable_rdn2 = RDN((self.attr1.upper(), self.value1.lower()))
|
|
|
|
mutable_rdn1 = EditableRDN((self.attr1.lower(), self.value1.upper()))
|
|
mutable_rdn2 = EditableRDN((self.attr1.upper(), self.value1.lower()))
|
|
|
|
# Immutable RDN's that are equal should hash to the same value.
|
|
# Mutable RDN's should not be hashable.
|
|
|
|
self.assertEqual(immutable_rdn1, immutable_rdn2)
|
|
self.assertEqual(immutable_rdn1, mutable_rdn1)
|
|
self.assertEqual(immutable_rdn1, mutable_rdn2)
|
|
self.assertEqual(mutable_rdn1, immutable_rdn2)
|
|
|
|
# Good, everyone's equal, now verify their hash values
|
|
|
|
self.assertEqual(hash(immutable_rdn1), hash(immutable_rdn2))
|
|
with self.assertRaises(TypeError):
|
|
hash(mutable_rdn1)
|
|
with self.assertRaises(TypeError):
|
|
hash(mutable_rdn2)
|
|
|
|
def test_coerce(self):
|
|
# Coerce an immutable to a mutable
|
|
immutable_rdn3 = RDN(self.rdn3)
|
|
mutable_rdn3 = EditableRDN(immutable_rdn3)
|
|
self.assertEqual(mutable_rdn3, self.rdn3)
|
|
self.assertEqual(mutable_rdn3, immutable_rdn3)
|
|
|
|
# Coerce a mutable to an immutable
|
|
mutable_rdn3 = EditableRDN(self.rdn3)
|
|
immutable_rdn3 = RDN(mutable_rdn3)
|
|
self.assertEqual(immutable_rdn3, self.rdn3)
|
|
self.assertEqual(immutable_rdn3, mutable_rdn3)
|
|
|
|
class TestDN(unittest.TestCase):
|
|
def setUp(self):
|
|
# ava1 must sort before ava2
|
|
self.attr1 = 'cn'
|
|
self.value1 = 'Bob'
|
|
self.str_ava1 = '%s=%s' % (self.attr1, self.value1)
|
|
self.ava1 = AVA(self.attr1, self.value1)
|
|
|
|
self.str_rdn1 = '%s=%s' % (self.attr1, self.value1)
|
|
self.rdn1 = RDN((self.attr1, self.value1))
|
|
|
|
self.attr2 = 'ou'
|
|
self.value2 = 'people'
|
|
self.str_ava2 = '%s=%s' % (self.attr2, self.value2)
|
|
self.ava2 = AVA(self.attr2, self.value2)
|
|
|
|
self.str_rdn2 = '%s=%s' % (self.attr2, self.value2)
|
|
self.rdn2 = RDN((self.attr2, self.value2))
|
|
|
|
self.str_dn1 = self.str_rdn1
|
|
self.dn1 = DN(self.rdn1)
|
|
|
|
self.str_dn2 = self.str_rdn2
|
|
self.dn2 = DN(self.rdn2)
|
|
|
|
self.str_dn3 = '%s,%s' % (self.str_rdn1, self.str_rdn2)
|
|
self.dn3 = DN(self.rdn1, self.rdn2)
|
|
|
|
self.base_rdn1 = RDN(('dc', 'redhat'))
|
|
self.base_rdn2 = RDN(('dc', 'com'))
|
|
self.base_dn = DN(self.base_rdn1, self.base_rdn2)
|
|
|
|
self.container_rdn1 = RDN(('cn', 'sudorules'))
|
|
self.container_rdn2 = RDN(('cn', 'sudo'))
|
|
self.container_dn = DN(self.container_rdn1, self.container_rdn2)
|
|
|
|
self.base_container_dn = DN((self.attr1, self.value1),
|
|
self.container_dn, self.base_dn)
|
|
|
|
|
|
def assertExpectedClass(self, klass, obj, component):
|
|
self.assertIs(obj.__class__, expected_class(klass, component))
|
|
|
|
def test_create(self):
|
|
for DN_class in (DN, EditableDN):
|
|
# Create with single attr,value pair
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[0].attr, unicode)
|
|
self.assertIsInstance(dn1[0].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
|
|
# Create with single attr,value pair passed as a tuple
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
|
|
# Creation with multiple attr,value string pairs should fail
|
|
with self.assertRaises(ValueError):
|
|
dn1 = DN_class(self.attr1, self.value1, self.attr2, self.value2)
|
|
|
|
# Create with multiple attr,value pairs passed as tuples & lists
|
|
dn1 = DN_class((self.attr1, self.value1), [self.attr2, self.value2])
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
self.assertEqual(dn1[1], self.rdn2)
|
|
|
|
# Create with multiple attr,value pairs passed as tuple and RDN
|
|
dn1 = DN_class((self.attr1, self.value1), RDN((self.attr2, self.value2)))
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
self.assertEqual(dn1[1], self.rdn2)
|
|
|
|
# Create with multiple attr,value pairs but reverse
|
|
# constructor parameter ordering. RDN ordering should also be
|
|
# reversed because DN's are a ordered sequence of RDN's
|
|
dn1 = DN_class((self.attr2, self.value2), (self.attr1, self.value1))
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn2)
|
|
self.assertEqual(dn1[1], self.rdn1)
|
|
|
|
# Create with single RDN object
|
|
dn1 = DN_class(self.rdn1)
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
|
|
# Create with multiple RDN objects, assure ordering is preserved.
|
|
dn1 = DN_class(self.rdn1, self.rdn2)
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
self.assertEqual(dn1[1], self.rdn2)
|
|
|
|
# Create with multiple RDN objects in different order, assure
|
|
# ordering is preserved.
|
|
dn1 = DN_class(self.rdn2, self.rdn1)
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn2)
|
|
self.assertEqual(dn1[1], self.rdn1)
|
|
|
|
# Create with single string with 1 RDN
|
|
dn1 = DN_class(self.str_rdn1)
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
|
|
# Create with single string with 2 RDN's
|
|
dn1 = DN_class(self.str_dn3)
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
self.assertIsInstance(dn1[i].attr, unicode)
|
|
self.assertIsInstance(dn1[i].value, unicode)
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
self.assertEqual(dn1[1], self.rdn2)
|
|
|
|
# Create with RDN, and 2 DN's (e.g. attr + container + base)
|
|
dn1 = DN_class((self.attr1, self.value1), self.container_dn, self.base_dn)
|
|
self.assertEqual(len(dn1), 5)
|
|
dn_str = ','.join([str(self.rdn1),
|
|
str(self.container_rdn1), str(self.container_rdn2),
|
|
str(self.base_rdn1), str(self.base_rdn2)])
|
|
self.assertEqual(str(dn1), dn_str)
|
|
|
|
def test_str(self):
|
|
for DN_class in (DN, EditableDN):
|
|
dn1 = DN_class(self.dn1)
|
|
dn2 = DN_class(self.dn2)
|
|
dn3 = DN_class(self.dn3)
|
|
|
|
self.assertEqual(str(dn1), self.str_dn1)
|
|
self.assertIsInstance(str(dn1), str)
|
|
|
|
self.assertEqual(str(dn2), self.str_dn2)
|
|
self.assertIsInstance(str(dn2), str)
|
|
|
|
self.assertEqual(str(dn3), self.str_dn3)
|
|
self.assertIsInstance(str(dn3), str)
|
|
|
|
def test_cmp(self):
|
|
for DN_class in (DN, EditableDN):
|
|
# Equality
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
|
|
self.assertTrue(dn1 == self.dn1)
|
|
self.assertFalse(dn1 != self.dn1)
|
|
|
|
self.assertTrue(dn1 == self.str_dn1)
|
|
self.assertFalse(dn1 != self.str_dn1)
|
|
|
|
result = cmp(dn1, self.dn1)
|
|
self.assertEqual(result, 0)
|
|
|
|
# Make dn1's attr greater
|
|
if DN_class.is_mutable:
|
|
dn1[0].attr = self.attr1 + "1"
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
dn1[0].attr = self.attr1 + "1"
|
|
dn1 = DN_class((self.attr1 + "1", self.value1))
|
|
|
|
self.assertFalse(dn1 == self.dn1)
|
|
self.assertTrue(dn1 != self.dn1)
|
|
|
|
result = cmp(dn1, self.dn1)
|
|
self.assertEqual(result, 1)
|
|
|
|
result = cmp(self.dn1, dn1)
|
|
self.assertEqual(result, -1)
|
|
|
|
# Reset dn1's attr, should be equal again
|
|
if DN_class.is_mutable:
|
|
dn1[0].attr = self.attr1
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
dn1[0].attr = self.attr1
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
|
|
result = cmp(dn1, self.dn1)
|
|
self.assertEqual(result, 0)
|
|
|
|
# Make dn1's value greater
|
|
# attr will be equal, this tests secondary comparision component
|
|
if DN_class.is_mutable:
|
|
dn1[0].value = self.value1 + "1"
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
dn1[0].value = self.value1 + "1"
|
|
dn1 = DN_class((self.attr1, self.value1 + "1"))
|
|
|
|
result = cmp(dn1, self.dn1)
|
|
self.assertEqual(result, 1)
|
|
|
|
result = cmp(self.dn1, dn1)
|
|
self.assertEqual(result, -1)
|
|
|
|
# Make sure dn's with more rdn's are greater
|
|
result = cmp(self.dn1, self.dn3)
|
|
self.assertEqual(result, -1)
|
|
result = cmp(self.dn3, self.dn1)
|
|
self.assertEqual(result, 1)
|
|
|
|
|
|
# Test startswith, endswith
|
|
container_dn = DN_class(self.container_dn)
|
|
base_container_dn = DN_class(self.base_container_dn)
|
|
|
|
self.assertTrue(base_container_dn.startswith(self.rdn1))
|
|
self.assertTrue(base_container_dn.startswith(self.dn1))
|
|
self.assertTrue(base_container_dn.startswith(self.dn1 + container_dn))
|
|
self.assertFalse(base_container_dn.startswith(self.dn2))
|
|
self.assertFalse(base_container_dn.startswith(self.rdn2))
|
|
self.assertTrue(base_container_dn.startswith((self.dn1)))
|
|
self.assertTrue(base_container_dn.startswith((self.rdn1)))
|
|
self.assertFalse(base_container_dn.startswith((self.rdn2)))
|
|
self.assertTrue(base_container_dn.startswith((self.rdn2, self.rdn1)))
|
|
self.assertTrue(base_container_dn.startswith((self.dn1, self.dn2)))
|
|
|
|
self.assertTrue(base_container_dn.endswith(self.base_dn))
|
|
self.assertTrue(base_container_dn.endswith(container_dn + self.base_dn))
|
|
self.assertFalse(base_container_dn.endswith(DN(self.base_rdn1)))
|
|
self.assertTrue(base_container_dn.endswith(DN(self.base_rdn2)))
|
|
self.assertTrue(base_container_dn.endswith((DN(self.base_rdn1), DN(self.base_rdn2))))
|
|
|
|
# Test "in" membership
|
|
self.assertTrue(self.container_rdn1 in container_dn)
|
|
self.assertTrue(container_dn in container_dn)
|
|
self.assertFalse(self.base_rdn1 in container_dn)
|
|
|
|
self.assertTrue(self.container_rdn1 in base_container_dn)
|
|
self.assertTrue(container_dn in base_container_dn)
|
|
self.assertTrue(container_dn + self.base_dn in
|
|
base_container_dn)
|
|
self.assertTrue(self.dn1 + container_dn + self.base_dn in
|
|
base_container_dn)
|
|
self.assertTrue(self.dn1 + container_dn + self.base_dn ==
|
|
base_container_dn)
|
|
|
|
self.assertFalse(self.container_rdn1 in self.base_dn)
|
|
|
|
def test_indexing(self):
|
|
for DN_class in (DN, EditableDN):
|
|
dn1 = DN_class(self.dn1)
|
|
dn2 = DN_class(self.dn2)
|
|
dn3 = DN_class(self.dn3)
|
|
|
|
self.assertEqual(dn1[0], self.rdn1)
|
|
self.assertEqual(dn1[self.rdn1.attr], self.rdn1.value)
|
|
with self.assertRaises(KeyError):
|
|
dn1['foo']
|
|
|
|
self.assertEqual(dn2[0], self.rdn2)
|
|
self.assertEqual(dn2[self.rdn2.attr], self.rdn2.value)
|
|
with self.assertRaises(KeyError):
|
|
dn2['foo']
|
|
|
|
self.assertEqual(dn3[0], self.rdn1)
|
|
self.assertEqual(dn3[self.rdn1.attr], self.rdn1.value)
|
|
self.assertEqual(dn3[1], self.rdn2)
|
|
self.assertEqual(dn3[self.rdn2.attr], self.rdn2.value)
|
|
with self.assertRaises(KeyError):
|
|
dn3['foo']
|
|
|
|
with self.assertRaises(TypeError):
|
|
dn3[1.0]
|
|
|
|
def test_assignments(self):
|
|
for DN_class in (DN, EditableDN):
|
|
dn_low = 0
|
|
dn_high = 6
|
|
|
|
rdn_args = make_rdn_args(dn_low, dn_high, 'tuple',
|
|
default_rdn_attr_arg, default_rdn_value_arg)
|
|
dn1 = DN_class(*rdn_args)
|
|
|
|
rdn_args = make_rdn_args(dn_low, dn_high, 'list',
|
|
default_rdn_attr_arg, default_rdn_value_arg)
|
|
dn2 = DN_class(*rdn_args)
|
|
|
|
rdn_args = make_rdn_args(dn_low, dn_high, 'RDN',
|
|
default_rdn_attr_arg, default_rdn_value_arg)
|
|
dn3 = DN_class(*rdn_args)
|
|
|
|
self.assertEqual(dn1, dn2)
|
|
self.assertEqual(dn1, dn3)
|
|
|
|
for i in range(dn_low, dn_high):
|
|
attr = default_rdn_attr_arg(i)
|
|
value = default_rdn_value_arg(i)
|
|
|
|
self.assertEqual(dn1[i].attr, attr)
|
|
self.assertEqual(dn1[i].value, value)
|
|
self.assertEqual(dn1[attr], value)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
|
|
self.assertEqual(dn2[i].attr, attr)
|
|
self.assertEqual(dn2[i].value, value)
|
|
self.assertEqual(dn2[attr], value)
|
|
self.assertExpectedClass(DN_class, dn2, 'self')
|
|
self.assertExpectedClass(DN_class, dn2[i], 'RDN')
|
|
for j in range(0, len(dn2[i])):
|
|
self.assertExpectedClass(DN_class, dn2[i][j], 'AVA')
|
|
|
|
self.assertEqual(dn3[i].attr, attr)
|
|
self.assertEqual(dn3[i].value, value)
|
|
self.assertEqual(dn3[attr], value)
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
self.assertExpectedClass(DN_class, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN_class, dn3[i][j], 'AVA')
|
|
|
|
|
|
for i in range(dn_low, dn_high):
|
|
if i % 2:
|
|
orig_attr = default_rdn_attr_arg(i)
|
|
attr = alt_rdn_attr_arg(i)
|
|
value = alt_rdn_value_arg(i)
|
|
|
|
if DN_class.is_mutable:
|
|
dn1[i] = attr, value
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
dn1[i] = attr, value
|
|
|
|
if DN_class.is_mutable:
|
|
dn2[orig_attr] = (attr, value)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
dn2[orig_attr] = (attr, value)
|
|
|
|
if DN_class.is_mutable:
|
|
dn3[i] = RDN((attr, value))
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
dn3[i] = RDN((attr, value))
|
|
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
|
|
self.assertExpectedClass(DN_class, dn2, 'self')
|
|
for i in range(0, len(dn2)):
|
|
self.assertExpectedClass(DN_class, dn2[i], 'RDN')
|
|
for j in range(0, len(dn2[i])):
|
|
self.assertExpectedClass(DN_class, dn2[i][j], 'AVA')
|
|
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN_class, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN_class, dn3[i][j], 'AVA')
|
|
|
|
|
|
if DN_class.is_mutable:
|
|
self.assertEqual(dn1, dn2)
|
|
self.assertEqual(dn1, dn3)
|
|
|
|
for i in range(dn_low, dn_high):
|
|
if i % 2:
|
|
attr = alt_rdn_attr_arg(i)
|
|
value = alt_rdn_value_arg(i)
|
|
else:
|
|
attr = default_rdn_attr_arg(i)
|
|
value = default_rdn_value_arg(i)
|
|
self.assertEqual(dn1[i].attr, attr)
|
|
self.assertEqual(dn1[i].value, value)
|
|
self.assertEqual(dn1[attr], value)
|
|
|
|
# Slices
|
|
slice_low = 2
|
|
slice_high = 4
|
|
slice_interval = range(slice_low, slice_high)
|
|
|
|
# Slices
|
|
# Assign via tuple
|
|
rdn_args = make_rdn_args(dn_low, dn_high, 'tuple',
|
|
default_rdn_attr_arg, default_rdn_value_arg)
|
|
dn = DN_class(*rdn_args)
|
|
|
|
dn_slice = make_rdn_args(slice_low, slice_high, 'tuple',
|
|
alt_rdn_attr_arg, alt_rdn_value_arg)
|
|
|
|
if DN_class.is_mutable:
|
|
dn[slice_low:slice_high] = dn_slice
|
|
for i in range(dn_low, dn_high):
|
|
if i in slice_interval:
|
|
attr = alt_rdn_attr_arg(i)
|
|
value = alt_rdn_value_arg(i)
|
|
else:
|
|
attr = default_rdn_attr_arg(i)
|
|
value = default_rdn_value_arg(i)
|
|
self.assertEqual(dn[i].attr, attr)
|
|
self.assertEqual(dn[i].value, value)
|
|
self.assertEqual(dn[attr], value)
|
|
|
|
query_slice = dn[slice_low:slice_high]
|
|
for i, query_rdn in enumerate(query_slice):
|
|
slice_rdn = RDN(dn_slice[i])
|
|
self.assertEqual(slice_rdn, query_rdn)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
dn[slice_low:slice_high] = dn_slice
|
|
|
|
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
# insert
|
|
dn = DN_class(self.rdn2)
|
|
|
|
if DN_class.is_mutable:
|
|
dn.insert(0, self.rdn1)
|
|
self.assertEqual(dn, self.dn3)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
dn.insert(0, self.rdn1)
|
|
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
dn = DN_class(self.rdn1)
|
|
|
|
if DN_class.is_mutable:
|
|
dn.insert(1, (self.attr2, self.value2))
|
|
self.assertEqual(dn, self.dn3)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
dn.insert(1, (self.attr2, self.value2))
|
|
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
# Slices
|
|
# Assign via RDN
|
|
rdn_args = make_rdn_args(dn_low, dn_high, 'tuple',
|
|
default_rdn_attr_arg, default_rdn_value_arg)
|
|
dn = DN_class(*rdn_args)
|
|
|
|
dn_slice = make_rdn_args(slice_low, slice_high, 'RDN',
|
|
alt_rdn_attr_arg, alt_rdn_value_arg)
|
|
|
|
if DN_class.is_mutable:
|
|
dn[slice_low:slice_high] = dn_slice
|
|
for i in range(dn_low, dn_high):
|
|
if i in slice_interval:
|
|
attr = alt_rdn_attr_arg(i)
|
|
value = alt_rdn_value_arg(i)
|
|
else:
|
|
attr = default_rdn_attr_arg(i)
|
|
value = default_rdn_value_arg(i)
|
|
self.assertEqual(dn[i].value, value)
|
|
self.assertEqual(dn[attr], value)
|
|
|
|
query_slice = dn[slice_low:slice_high]
|
|
for i, query_rdn in enumerate(query_slice):
|
|
slice_rdn = dn_slice[i]
|
|
self.assertEqual(slice_rdn, query_rdn)
|
|
else:
|
|
with self.assertRaises(TypeError):
|
|
dn[slice_low:slice_high] = dn_slice
|
|
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
def test_iter(self):
|
|
for DN_class in (DN, EditableDN):
|
|
dn1 = DN_class(self.dn1)
|
|
dn2 = DN_class(self.dn2)
|
|
dn3 = DN_class(self.dn3)
|
|
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertEqual(dn1[:], [self.rdn1])
|
|
for i, ava in enumerate(dn1):
|
|
if i == 0:
|
|
self.assertEqual(ava, self.rdn1)
|
|
else:
|
|
self.fail("got iteration index %d, but len=%d" % (i, len(self.rdn1)))
|
|
|
|
self.assertEqual(len(dn2), 1)
|
|
self.assertEqual(dn2[:], [self.rdn2])
|
|
for i, ava in enumerate(dn2):
|
|
if i == 0:
|
|
self.assertEqual(ava, self.rdn2)
|
|
else:
|
|
self.fail("got iteration index %d, but len=%d" % (i, len(self.rdn2)))
|
|
|
|
self.assertEqual(len(dn3), 2)
|
|
self.assertEqual(dn3[:], [self.rdn1, self.rdn2])
|
|
for i, ava in enumerate(dn3):
|
|
if i == 0:
|
|
self.assertEqual(ava, self.rdn1)
|
|
elif i == 1:
|
|
self.assertEqual(ava, self.rdn2)
|
|
else:
|
|
self.fail("got iteration index %d, but len=%d" % (i, len(dn3)))
|
|
|
|
|
|
def test_concat(self):
|
|
for DN_class in (DN, EditableDN):
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
dn2 = DN_class([self.attr2, self.value2])
|
|
|
|
# in-place addtion
|
|
|
|
# Note: If __iadd__ is not available Python will emulate += by
|
|
# replacing the lhs object with the result of __add__ (if available).
|
|
# Thus += works for both immutable and mutable RDN,DN object, the only
|
|
# difference is an immutable without __iadd__ will have a different object
|
|
# on the lhs after the operator evaluates.
|
|
|
|
dn1 += dn2
|
|
self.assertEqual(dn1, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
|
|
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
dn1 += self.rdn2
|
|
self.assertEqual(dn1, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
|
|
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
dn1 += self.dn2
|
|
self.assertEqual(dn1, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
|
|
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
dn1 += self.str_dn2
|
|
self.assertEqual(dn1, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN_class, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN_class, dn1[i][j], 'AVA')
|
|
|
|
|
|
# concatenation
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
dn3 = dn1 + dn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN_class, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN_class, dn3[i][j], 'AVA')
|
|
|
|
|
|
dn1 = DN_class((self.attr1, self.value1))
|
|
dn3 = dn1 + self.rdn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN_class, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN_class, dn3[i][j], 'AVA')
|
|
|
|
dn3 = dn1 + self.str_rdn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN_class, dn3[i], 'RDN')
|
|
self.assertExpectedClass(DN_class, dn3[i][0], 'AVA')
|
|
|
|
dn3 = dn1 + self.str_dn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN_class, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN_class, dn3[i][j], 'AVA')
|
|
|
|
dn3 = dn1 + self.dn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
self.assertExpectedClass(DN_class, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN_class, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN_class, dn3[i][j], 'AVA')
|
|
|
|
def test_find(self):
|
|
for DN_class in (DN, EditableDN):
|
|
# -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
|
|
dn = DN_class('t=0,t=1,cn=bob,t=3,t=4,t=5,cn=bob,t=7,t=8,t=9')
|
|
pat = DN_class('cn=bob')
|
|
|
|
# forward
|
|
self.assertEqual(dn.find(pat), 2)
|
|
self.assertEqual(dn.find(pat, 1), 2)
|
|
self.assertEqual(dn.find(pat, 1, 3), 2)
|
|
self.assertEqual(dn.find(pat, 2, 3), 2)
|
|
self.assertEqual(dn.find(pat, 6), 6)
|
|
|
|
self.assertEqual(dn.find(pat, 7), -1)
|
|
self.assertEqual(dn.find(pat, 1, 2), -1)
|
|
|
|
with self.assertRaises(ValueError):
|
|
self.assertEqual(dn.index(pat, 7), -1)
|
|
with self.assertRaises(ValueError):
|
|
self.assertEqual(dn.index(pat, 1, 2), -1)
|
|
|
|
# reverse
|
|
self.assertEqual(dn.rfind(pat), 6)
|
|
self.assertEqual(dn.rfind(pat, -4), 6)
|
|
self.assertEqual(dn.rfind(pat, 6), 6)
|
|
self.assertEqual(dn.rfind(pat, 6, 8), 6)
|
|
self.assertEqual(dn.rfind(pat, 6, 8), 6)
|
|
self.assertEqual(dn.rfind(pat, -8), 6)
|
|
self.assertEqual(dn.rfind(pat, -8, -4), 6)
|
|
self.assertEqual(dn.rfind(pat, -8, -5), 2)
|
|
|
|
self.assertEqual(dn.rfind(pat, 7), -1)
|
|
self.assertEqual(dn.rfind(pat, -3), -1)
|
|
|
|
with self.assertRaises(ValueError):
|
|
self.assertEqual(dn.rindex(pat, 7), -1)
|
|
with self.assertRaises(ValueError):
|
|
self.assertEqual(dn.rindex(pat, -3), -1)
|
|
|
|
|
|
def test_replace(self):
|
|
for DN_class in (DN, EditableDN):
|
|
dn = DN_class('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=8,t=9')
|
|
pat = DN('cn=bob')
|
|
replacement = DN('cn=bob')
|
|
|
|
if DN_class.is_mutable:
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertEqual(n_replaced, 0)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
pat = DN('t=2')
|
|
if DN_class.is_mutable:
|
|
expected_dn = DN('t=0,t=1,cn=bob,t=3,t=4,t=5,t=6,t=7,t=8,t=9')
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertEqual(n_replaced, 1)
|
|
self.assertEqual(dn, expected_dn)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
dn = DN_class('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=2,t=9')
|
|
if DN_class.is_mutable:
|
|
expected_dn = DN('t=0,t=1,cn=bob,t=3,t=4,t=5,t=6,t=7,t=2,t=9')
|
|
n_replaced = dn.replace(pat, replacement, 1)
|
|
self.assertEqual(n_replaced, 1)
|
|
self.assertEqual(dn, expected_dn)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
n_replaced = dn.replace(pat, replacement, 1)
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
dn = DN_class('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=2,t=9')
|
|
if DN_class.is_mutable:
|
|
expected_dn = DN('t=0,t=1,cn=bob,t=3,t=4,t=5,t=6,t=7,t=2,t=9')
|
|
n_replaced = dn.replace(pat, replacement, 1)
|
|
self.assertEqual(n_replaced, 1)
|
|
self.assertEqual(dn, expected_dn)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
n_replaced = dn.replace(pat, replacement, 1)
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
replacement = DN('cn=bob,ou=people')
|
|
|
|
dn = DN_class('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=2,t=9')
|
|
if DN_class.is_mutable:
|
|
expected_dn = DN('t=0,t=1,cn=bob,ou=people,t=3,t=4,t=5,t=6,t=7,t=2,t=9')
|
|
n_replaced = dn.replace(pat, replacement, 1)
|
|
self.assertEqual(n_replaced, 1)
|
|
self.assertEqual(dn, expected_dn)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
n_replaced = dn.replace(pat, replacement, 1)
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
dn = DN_class('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=2,t=9')
|
|
if DN_class.is_mutable:
|
|
expected_dn = DN('t=0,t=1,cn=bob,ou=people,t=3,t=4,t=5,t=6,t=7,cn=bob,ou=people,t=9')
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertEqual(n_replaced, 2)
|
|
self.assertEqual(dn, expected_dn)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
pat = DN('t=3,t=4')
|
|
replacement = DN('cn=bob')
|
|
dn = DN_class('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=8,t=9')
|
|
if DN_class.is_mutable:
|
|
expected_dn = DN('t=0,t=1,t=2,cn=bob,t=5,t=6,t=7,t=8,t=9')
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertEqual(n_replaced, 1)
|
|
self.assertEqual(dn, expected_dn)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
pat = DN('t=3,t=4')
|
|
replacement = DN('cn=bob,ou=people')
|
|
dn = DN_class('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=8,t=9')
|
|
if DN_class.is_mutable:
|
|
expected_dn = DN('t=0,t=1,t=2,cn=bob,ou=people,t=5,t=6,t=7,t=8,t=9')
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertEqual(n_replaced, 1)
|
|
self.assertEqual(dn, expected_dn)
|
|
else:
|
|
with self.assertRaises(AttributeError):
|
|
n_replaced = dn.replace(pat, replacement)
|
|
self.assertExpectedClass(DN_class, dn, 'self')
|
|
for i in range(0, len(dn)):
|
|
self.assertExpectedClass(DN_class, dn[i], 'RDN')
|
|
for j in range(0, len(dn[i])):
|
|
self.assertExpectedClass(DN_class, dn[i][j], 'AVA')
|
|
|
|
def test_hashing(self):
|
|
# create DN's that are equal but differ in case
|
|
immutable_dn1 = DN((self.attr1.lower(), self.value1.upper()))
|
|
immutable_dn2 = DN((self.attr1.upper(), self.value1.lower()))
|
|
|
|
mutable_dn1 = EditableDN((self.attr1.lower(), self.value1.upper()))
|
|
mutable_dn2 = EditableDN((self.attr1.upper(), self.value1.lower()))
|
|
|
|
# Immutable DN's that are equal should hash to the same value.
|
|
# Mutable DN's should not be hashable.
|
|
|
|
self.assertEqual(immutable_dn1, immutable_dn2)
|
|
self.assertEqual(immutable_dn1, mutable_dn1)
|
|
self.assertEqual(immutable_dn1, mutable_dn2)
|
|
self.assertEqual(mutable_dn1, immutable_dn2)
|
|
|
|
# Good, everyone's equal, now verify their hash values
|
|
|
|
self.assertEqual(hash(immutable_dn1), hash(immutable_dn2))
|
|
with self.assertRaises(TypeError):
|
|
hash(mutable_dn1)
|
|
with self.assertRaises(TypeError):
|
|
hash(mutable_dn2)
|
|
|
|
# Different immutable DN objects with the same value should
|
|
# map to 1 common key and 1 member in a set. The key and
|
|
# member are based on the object's value.
|
|
#
|
|
# Mutable DN objects should be unhashable.
|
|
|
|
for DN_class in (DN, EditableDN):
|
|
dn1_a = DN_class(self.dn1)
|
|
dn1_b = DN_class(self.dn1)
|
|
|
|
dn2_a = DN_class(self.dn2)
|
|
dn2_b = DN_class(self.dn2)
|
|
|
|
dn3_a = DN_class(self.dn3)
|
|
dn3_b = DN_class(self.dn3)
|
|
|
|
self.assertEqual(dn1_a, dn1_b)
|
|
self.assertEqual(dn2_a, dn2_b)
|
|
self.assertEqual(dn3_a, dn3_b)
|
|
|
|
d = dict()
|
|
s = set()
|
|
|
|
if DN_class.is_mutable:
|
|
with self.assertRaises(TypeError):
|
|
d[dn1_a] = str(dn1_a)
|
|
with self.assertRaises(TypeError):
|
|
d[dn1_b] = str(dn1_b)
|
|
with self.assertRaises(TypeError):
|
|
d[dn2_a] = str(dn2_a)
|
|
with self.assertRaises(TypeError):
|
|
d[dn2_b] = str(dn2_b)
|
|
|
|
with self.assertRaises(TypeError):
|
|
s.add(dn1_a)
|
|
with self.assertRaises(TypeError):
|
|
s.add(dn1_b)
|
|
with self.assertRaises(TypeError):
|
|
s.add(dn2_a)
|
|
with self.assertRaises(TypeError):
|
|
s.add(dn2_b)
|
|
else:
|
|
d[dn1_a] = str(dn1_a)
|
|
d[dn1_b] = str(dn1_b)
|
|
d[dn2_a] = str(dn2_a)
|
|
d[dn2_b] = str(dn2_b)
|
|
|
|
s.add(dn1_a)
|
|
s.add(dn1_b)
|
|
s.add(dn2_a)
|
|
s.add(dn2_b)
|
|
|
|
self.assertEqual(len(d), 2)
|
|
self.assertEqual(len(s), 2)
|
|
self.assertEqual(sorted(d.keys()), sorted([dn1_a, dn2_a]))
|
|
self.assertEqual(sorted(s), sorted([dn1_a, dn2_a]))
|
|
|
|
self.assertTrue(dn1_a in d)
|
|
self.assertTrue(dn1_b in d)
|
|
self.assertTrue(dn2_a in d)
|
|
self.assertTrue(dn2_b in d)
|
|
self.assertFalse(dn3_a in d)
|
|
self.assertFalse(dn3_b in d)
|
|
|
|
self.assertTrue(d.has_key(dn1_a))
|
|
self.assertTrue(d.has_key(dn1_b))
|
|
self.assertTrue(d.has_key(dn2_a))
|
|
self.assertTrue(d.has_key(dn2_b))
|
|
self.assertFalse(d.has_key(dn3_a))
|
|
self.assertFalse(d.has_key(dn3_b))
|
|
|
|
self.assertTrue(dn1_a in s)
|
|
self.assertTrue(dn1_b in s)
|
|
self.assertTrue(dn2_a in s)
|
|
self.assertTrue(dn2_b in s)
|
|
self.assertFalse(dn3_a in s)
|
|
self.assertFalse(dn3_b in s)
|
|
|
|
def test_coerce(self):
|
|
# Coerce an immutable to a mutable
|
|
immutable_dn3 = DN(self.dn3)
|
|
mutable_dn3 = EditableDN(immutable_dn3)
|
|
self.assertEqual(mutable_dn3, self.dn3)
|
|
self.assertEqual(mutable_dn3, immutable_dn3)
|
|
|
|
# Coerce a mutable to an immutable
|
|
mutable_dn3 = EditableDN(self.dn3)
|
|
immutable_dn3 = DN(mutable_dn3)
|
|
self.assertEqual(immutable_dn3, self.dn3)
|
|
self.assertEqual(immutable_dn3, mutable_dn3)
|
|
|
|
class TestEscapes(unittest.TestCase):
|
|
def setUp(self):
|
|
self.privilege = 'R,W privilege'
|
|
self.dn_str_hex_escape = 'cn=R\\2cW privilege,cn=privileges,cn=pbac,dc=idm,dc=lab,dc=bos,dc=redhat,dc=com'
|
|
self.dn_str_backslash_escape = 'cn=R\\,W privilege,cn=privileges,cn=pbac,dc=idm,dc=lab,dc=bos,dc=redhat,dc=com'
|
|
|
|
def test_escape(self):
|
|
for DN_class in (DN, EditableDN):
|
|
dn = DN_class(self.dn_str_hex_escape)
|
|
self.assertEqual(dn['cn'], self.privilege)
|
|
self.assertEqual(dn[0].value, self.privilege)
|
|
|
|
dn = DN_class(self.dn_str_backslash_escape)
|
|
self.assertEqual(dn['cn'], self.privilege)
|
|
self.assertEqual(dn[0].value, self.privilege)
|
|
|
|
class TestInternationalization(unittest.TestCase):
|
|
def setUp(self):
|
|
# Hello in Arabic
|
|
self.arabic_hello_utf8 = '\xd9\x85\xd9\x83\xd9\x8a\xd9\x84' + \
|
|
'\xd8\xb9\x20\xd9\x85\xd8\xa7\xd9' + \
|
|
'\x84\xd9\x91\xd8\xb3\xd9\x84\xd8\xa7'
|
|
|
|
self.arabic_hello_unicode = self.arabic_hello_utf8.decode('utf-8')
|
|
|
|
def test_i18n(self):
|
|
self.assertEqual(self.arabic_hello_utf8,
|
|
self.arabic_hello_unicode.encode('utf-8'))
|
|
|
|
# AVA's
|
|
# test attr i18n
|
|
for AVA_class in (AVA, EditableAVA):
|
|
ava1 = AVA_class(self.arabic_hello_unicode, 'foo')
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
self.assertEqual(ava1.attr, self.arabic_hello_unicode)
|
|
self.assertEqual(str(ava1), self.arabic_hello_utf8+'=foo')
|
|
|
|
ava1 = AVA_class(self.arabic_hello_utf8, 'foo')
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
self.assertEqual(ava1.attr, self.arabic_hello_unicode)
|
|
self.assertEqual(str(ava1), self.arabic_hello_utf8+'=foo')
|
|
|
|
# test value i18n
|
|
ava1 = AVA_class('cn', self.arabic_hello_unicode)
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
self.assertEqual(ava1.value, self.arabic_hello_unicode)
|
|
self.assertEqual(str(ava1), 'cn='+self.arabic_hello_utf8)
|
|
|
|
ava1 = AVA_class('cn', self.arabic_hello_utf8)
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
self.assertEqual(ava1.value, self.arabic_hello_unicode)
|
|
self.assertEqual(str(ava1), 'cn='+self.arabic_hello_utf8)
|
|
|
|
# RDN's
|
|
# test attr i18n
|
|
for RDN_class in (RDN, EditableRDN):
|
|
rdn1 = RDN_class((self.arabic_hello_unicode, 'foo'))
|
|
self.assertIsInstance(rdn1.attr, unicode)
|
|
self.assertIsInstance(rdn1.value, unicode)
|
|
self.assertEqual(rdn1.attr, self.arabic_hello_unicode)
|
|
self.assertEqual(str(rdn1), self.arabic_hello_utf8+'=foo')
|
|
|
|
rdn1 = RDN_class((self.arabic_hello_utf8, 'foo'))
|
|
self.assertIsInstance(rdn1.attr, unicode)
|
|
self.assertIsInstance(rdn1.value, unicode)
|
|
self.assertEqual(rdn1.attr, self.arabic_hello_unicode)
|
|
self.assertEqual(str(rdn1), self.arabic_hello_utf8+'=foo')
|
|
|
|
# test value i18n
|
|
rdn1 = RDN_class(('cn', self.arabic_hello_unicode))
|
|
self.assertIsInstance(rdn1.attr, unicode)
|
|
self.assertIsInstance(rdn1.value, unicode)
|
|
self.assertEqual(rdn1.value, self.arabic_hello_unicode)
|
|
self.assertEqual(str(rdn1), 'cn='+self.arabic_hello_utf8)
|
|
|
|
rdn1 = RDN_class(('cn', self.arabic_hello_utf8))
|
|
self.assertIsInstance(rdn1.attr, unicode)
|
|
self.assertIsInstance(rdn1.value, unicode)
|
|
self.assertEqual(rdn1.value, self.arabic_hello_unicode)
|
|
self.assertEqual(str(rdn1), 'cn='+self.arabic_hello_utf8)
|
|
|
|
# DN's
|
|
# test attr i18n
|
|
for DN_class in (DN, EditableDN):
|
|
dn1 = DN_class((self.arabic_hello_unicode, 'foo'))
|
|
self.assertIsInstance(dn1[0].attr, unicode)
|
|
self.assertIsInstance(dn1[0].value, unicode)
|
|
self.assertEqual(dn1[0].attr, self.arabic_hello_unicode)
|
|
self.assertEqual(str(dn1), self.arabic_hello_utf8+'=foo')
|
|
|
|
dn1 = DN_class((self.arabic_hello_utf8, 'foo'))
|
|
self.assertIsInstance(dn1[0].attr, unicode)
|
|
self.assertIsInstance(dn1[0].value, unicode)
|
|
self.assertEqual(dn1[0].attr, self.arabic_hello_unicode)
|
|
self.assertEqual(str(dn1), self.arabic_hello_utf8+'=foo')
|
|
|
|
# test value i18n
|
|
dn1 = DN_class(('cn', self.arabic_hello_unicode))
|
|
self.assertIsInstance(dn1[0].attr, unicode)
|
|
self.assertIsInstance(dn1[0].value, unicode)
|
|
self.assertEqual(dn1[0].value, self.arabic_hello_unicode)
|
|
self.assertEqual(str(dn1), 'cn='+self.arabic_hello_utf8)
|
|
|
|
dn1 = DN_class(('cn', self.arabic_hello_utf8))
|
|
self.assertIsInstance(dn1[0].attr, unicode)
|
|
self.assertIsInstance(dn1[0].value, unicode)
|
|
self.assertEqual(dn1[0].value, self.arabic_hello_unicode)
|
|
self.assertEqual(str(dn1), 'cn='+self.arabic_hello_utf8)
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|