mirror of
https://salsa.debian.org/freeipa-team/freeipa.git
synced 2024-12-26 00:41:25 -06:00
5e96fbc22a
Part of the effort to port FreeIPA to Arch Linux, where Python 3 is the default. FreeIPA hasn't been ported to Python 3, so the code must be modified to run /usr/bin/python2 https://fedorahosted.org/freeipa/ticket/3438 Updated by pviktori@redhat.com
1938 lines
78 KiB
Python
1938 lines
78 KiB
Python
#!/usr/bin/python2
|
|
|
|
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()
|