public/freeipa
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e2c8b9eee406c2d05dd82dfd8bfae75a079fc88b
freeipa/tests/test_ipalib/test_dn.py
T
John Dennis 264ed38fa2 Make AVA, RDN & DN comparison case insensitive. No need for lowercase normalization. 
Replace deepcopy with constructor (i.e. type call)
Can now "clone" with configuration changes by passing object
of the same type to it's constructor, e.g.
dn1 = DN(('cn', 'foo'))
dn2 = DN(dn1)
dn2 = DN(dn1, first_key_match=False)

Remove pairwise grouping for RDN's. Had previously removed it
for DN's, left it in for RDN's because it seemed to make sense
because of the way RDN's work but consistency is a higher goal.

Add keyword constructor parameters to pass configuration options.

Make first_key_match a configuration keyword.

Updated documentation.

Updated unit test.

FWIW, I noticed the unittest is now running 2x faster, not sure why,
removal of deepcopy? Anyway, hard to argue with performance doubling.
2011-07-27 20:58:48 -04:00

983 lines
34 KiB
Python
Raw Blame History

#!/usr/bin/python
import unittest
from ipalib.dn import AVA, RDN, DN
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
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)
def test_create(self):
# Create with attr,value pair
ava1 = AVA(self.attr1, self.value1)
self.assertEqual(ava1, self.ava1)
# Create with "attr=value" string
ava1 = AVA(self.str_ava1)
self.assertEqual(ava1, self.ava1)
# Create with tuple (attr, value)
ava1 = AVA((self.attr1, self.value1))
self.assertEqual(ava1, self.ava1)
# Create with list [attr, value]
ava1 = AVA([self.attr1, self.value1])
self.assertEqual(ava1, self.ava1)
# Create with no args should fail
with self.assertRaises(TypeError):
AVA()
# Create with more than 2 args should fail
with self.assertRaises(TypeError):
AVA(self.attr1, self.value1, self.attr1)
# Create with 1 arg which is not string should fail
with self.assertRaises(TypeError):
AVA(1)
# Create with malformed AVA string should fail
with self.assertRaises(ValueError):
AVA("cn")
# Create with non-string parameters, should fail
with self.assertRaises(TypeError):
AVA(1, self.value1)
with self.assertRaises(TypeError):
AVA(self.attr1, 1)
with self.assertRaises(TypeError):
AVA((1, self.value1))
with self.assertRaises(TypeError):
AVA((self.attr1, 1))
def test_encoding(self):
# Create with attr,value pair
ava1 = AVA(self.attr1, self.value1)
self.assertEqual(ava1, self.ava1)
self.assertIsInstance(ava1.attr, unicode)
self.assertIsInstance(ava1.value, unicode)
ava1 = AVA(unicode(self.attr1), self.value1)
self.assertEqual(ava1, self.ava1)
self.assertIsInstance(ava1.attr, unicode)
self.assertIsInstance(ava1.value, unicode)
ava1 = AVA(self.attr1, unicode(self.value1))
self.assertEqual(ava1, self.ava1)
self.assertIsInstance(ava1.attr, unicode)
self.assertIsInstance(ava1.value, unicode)
# Create with "attr=value" string
ava1 = AVA(self.str_ava1)
self.assertEqual(ava1, self.ava1)
self.assertIsInstance(ava1.attr, unicode)
self.assertIsInstance(ava1.value, unicode)
ava1 = AVA(unicode(self.ava1))
self.assertEqual(ava1, self.ava1)
self.assertIsInstance(ava1.attr, unicode)
self.assertIsInstance(ava1.value, unicode)
# Create with tuple (attr, value)
ava1 = AVA((unicode(self.attr1), self.value1))
self.assertEqual(ava1, self.ava1)
self.assertIsInstance(ava1.attr, unicode)
self.assertIsInstance(ava1.value, unicode)
ava1 = AVA((self.attr1, unicode(self.value1)))
self.assertEqual(ava1, self.ava1)
self.assertIsInstance(ava1.attr, unicode)
self.assertIsInstance(ava1.value, unicode)
def test_indexing(self):
self.assertEqual(self.ava1[self.attr1], self.value1)
with self.assertRaises(KeyError):
self.ava1['foo']
with self.assertRaises(TypeError):
self.ava1[0]
def test_properties(self):
self.assertEqual(self.ava1.attr, self.attr1)
self.assertEqual(self.ava1.value, self.value1)
def test_str(self):
self.assertEqual(str(self.ava1), self.str_ava1)
self.assertIsInstance(str(self.ava1), str)
def test_cmp(self):
# Equality
ava1 = AVA(self.attr1, self.value1)
self.assertTrue(ava1 == self.ava1)
self.assertFalse(ava1 != self.ava1)
result = cmp(ava1, self.ava1)
self.assertEqual(result, 0)
# Upper case attr should still be equal
ava1 = AVA(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(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
ava1.attr = self.attr1 + "1"
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
ava1.attr = self.attr1
result = cmp(ava1, self.ava1)
self.assertEqual(result, 0)
# Make ava1's value greater
# attr will be equal, this tests secondary comparision component
ava1.value = self.value1 + "1"
result = cmp(ava1, self.ava1)
self.assertEqual(result, 1)
result = cmp(self.ava1, ava1)
self.assertEqual(result, -1)
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 test_create(self):
# Create with single attr,value pair
rdn1 = RDN((self.attr1, self.value1))
self.assertEqual(len(rdn1), 1)
self.assertEqual(rdn1, self.rdn1)
self.assertIsInstance(rdn1[0], AVA)
self.assertEqual(rdn1[0], self.ava1)
# Create with multiple attr,value pairs
rdn3 = RDN((self.attr1, self.value1), (self.attr2, self.value2))
self.assertEqual(len(rdn3), 2)
self.assertEqual(rdn3, self.rdn3)
self.assertIsInstance(rdn3[0], AVA)
self.assertEqual(rdn3[0], self.ava1)
self.assertIsInstance(rdn3[1], AVA)
self.assertEqual(rdn3[1], self.ava2)
# Create with multiple attr,value pairs passed as lists
rdn3 = RDN([self.attr1, self.value1], [self.attr2, self.value2])
self.assertEqual(len(rdn3), 2)
self.assertEqual(rdn3, self.rdn3)
self.assertIsInstance(rdn3[0], AVA)
self.assertEqual(rdn3[0], self.ava1)
self.assertIsInstance(rdn3[1], AVA)
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((self.attr2, self.value2), (self.attr1, self.value1))
self.assertEqual(len(rdn3), 2)
self.assertEqual(rdn3, self.rdn3)
self.assertIsInstance(rdn3[0], AVA)
self.assertEqual(rdn3[0], self.ava1)
self.assertIsInstance(rdn3[1], AVA)
self.assertEqual(rdn3[1], self.ava2)
# Create with single AVA object
rdn1 = RDN(self.ava1)
self.assertEqual(len(rdn1), 1)
self.assertEqual(rdn1, self.rdn1)
self.assertIsInstance(rdn1[0], AVA)
self.assertEqual(rdn1[0], self.ava1)
# Create with multiple AVA objects
rdn3 = RDN(self.ava1, self.ava2)
self.assertEqual(len(rdn3), 2)
self.assertEqual(rdn3, self.rdn3)
self.assertIsInstance(rdn3[0], AVA)
self.assertEqual(rdn3[0], self.ava1)
self.assertIsInstance(rdn3[1], AVA)
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(self.ava2, self.ava1)
self.assertEqual(len(rdn3), 2)
self.assertEqual(rdn3, self.rdn3)
self.assertIsInstance(rdn3[0], AVA)
self.assertEqual(rdn3[0], self.ava1)
self.assertIsInstance(rdn3[1], AVA)
self.assertEqual(rdn3[1], self.ava2)
# Create with single string with 1 AVA
rdn1 = RDN(self.str_rdn1)
self.assertEqual(len(rdn1), 1)
self.assertEqual(rdn1, self.rdn1)
self.assertIsInstance(rdn1[0], AVA)
self.assertEqual(rdn1[0], self.ava1)
# Create with single string with 2 AVA's
rdn3 = RDN(self.str_rdn3)
self.assertEqual(len(rdn3), 2)
self.assertEqual(rdn3, self.rdn3)
self.assertIsInstance(rdn3[0], AVA)
self.assertEqual(rdn3[0], self.ava1)
self.assertIsInstance(rdn3[1], AVA)
self.assertEqual(rdn3[1], self.ava2)
def test_properties(self):
self.assertEqual(self.rdn1.attr, self.attr1)
self.assertIsInstance(self.rdn1.attr, unicode)
self.assertEqual(self.rdn1.value, self.value1)
self.assertIsInstance(self.rdn1.value, unicode)
self.assertEqual(self.rdn2.attr, self.attr2)
self.assertIsInstance(self.rdn2.attr, unicode)
self.assertEqual(self.rdn2.value, self.value2)
self.assertIsInstance(self.rdn2.value, unicode)
self.assertEqual(self.rdn3.attr, self.attr1)
self.assertIsInstance(self.rdn3.attr, unicode)
self.assertEqual(self.rdn3.value, self.value1)
self.assertIsInstance(self.rdn3.value, unicode)
def test_str(self):
self.assertEqual(str(self.rdn1), self.str_rdn1)
self.assertIsInstance(str(self.rdn1), str)
self.assertEqual(str(self.rdn2), self.str_rdn2)
self.assertIsInstance(str(self.rdn2), str)
self.assertEqual(str(self.rdn3), self.str_rdn3)
self.assertIsInstance(str(self.rdn3), str)
def test_cmp(self):
# Equality
rdn1 = RDN((self.attr1, self.value1))
self.assertTrue(rdn1 == self.rdn1)
self.assertFalse(rdn1 != self.rdn1)
result = cmp(rdn1, self.rdn1)
self.assertEqual(result, 0)
# Make rdn1's attr greater
rdn1.attr = self.attr1 + "1"
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
rdn1.attr = self.attr1
result = cmp(rdn1, self.rdn1)
self.assertEqual(result, 0)
# Make rdn1's value greater
# attr will be equal, this tests secondary comparision component
rdn1.value = 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):
self.assertEqual(self.rdn1[0], self.ava1)
self.assertEqual(self.rdn1[self.ava1.attr], self.ava1.value)
with self.assertRaises(KeyError):
self.rdn1['foo']
self.assertEqual(self.rdn2[0], self.ava2)
self.assertEqual(self.rdn2[self.ava2.attr], self.ava2.value)
with self.assertRaises(KeyError):
self.rdn2['foo']
self.assertEqual(self.rdn3[0], self.ava1)
self.assertEqual(self.rdn3[self.ava1.attr], self.ava1.value)
self.assertEqual(self.rdn3[1], self.ava2)
self.assertEqual(self.rdn3[self.ava2.attr], self.ava2.value)
with self.assertRaises(KeyError):
self.rdn3['foo']
self.assertEqual(self.rdn1.attr, self.attr1)
self.assertEqual(self.rdn1.value, self.value1)
with self.assertRaises(TypeError):
self.rdn3[1.0]
# Slices
self.assertEqual(self.rdn3[0:1], [self.ava1])
self.assertEqual(self.rdn3[:], [self.ava1, self.ava2])
def test_assignments(self):
rdn = RDN((self.attr1, self.value1))
rdn[0] = self.ava2
self.assertEqual(rdn, self.rdn2)
rdn = RDN((self.attr1, self.value1))
rdn[0] = (self.attr2, self.value2)
self.assertEqual(rdn, self.rdn2)
rdn = RDN((self.attr1, self.value1))
rdn[self.attr1] = self.str_ava2
self.assertEqual(rdn[0], self.ava2)
# Can't assign multiples to single entry
rdn = RDN((self.attr1, self.value1))
with self.assertRaises(TypeError):
rdn[self.attr1] = self.str_ava3
rdn = RDN((self.attr1, self.value1))
with self.assertRaises(TypeError):
rdn[self.attr1] = (self.attr1, self.value1, self.attr2, self.value2)
rdn = RDN((self.attr1, self.value1))
with self.assertRaises(TypeError):
rdn[self.attr1] = [(self.attr1, self.value1), (self.attr2, self.value2)]
# Slices
rdn = RDN((self.attr1, self.value1))
self.assertEqual(rdn, self.rdn1)
rdn[0:1] = [self.ava2]
self.assertEqual(rdn, self.rdn2)
rdn = RDN((self.attr1, self.value1))
self.assertEqual(rdn, self.rdn1)
rdn[:] = [(self.attr2, self.value2)]
self.assertEqual(rdn, self.rdn2)
rdn = RDN((self.attr1, self.value1))
self.assertEqual(rdn, self.rdn1)
rdn[:] = [(self.attr1, self.value1),(self.attr2, self.value2)]
self.assertEqual(rdn, self.rdn3)
rdn = RDN((self.attr1, self.value1))
self.assertEqual(rdn, self.rdn1)
rdn[0:1] = [(self.attr1, self.value1), (self.attr2, self.value2)]
self.assertEqual(rdn, self.rdn3)
def test_iter(self):
self.assertEqual(len(self.rdn1), 1)
self.assertEqual(self.rdn1[:], [self.ava1])
for i, ava in enumerate(self.rdn1):
if i == 0:
self.assertEqual(ava, self.ava1)
else:
self.fail("got iteration index %d, but len=%d" % (i, len(self.rdn1)))
self.assertEqual(len(self.rdn2), 1)
self.assertEqual(self.rdn2[:], [self.ava2])
for i, ava in enumerate(self.rdn2):
if i == 0:
self.assertEqual(ava, self.ava2)
else:
self.fail("got iteration index %d, but len=%d" % (i, len(self.rdn2)))
self.assertEqual(len(self.rdn3), 2)
self.assertEqual(self.rdn3[:], [self.ava1, self.ava2])
for i, ava in enumerate(self.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(self.rdn3)))
def test_concat(self):
rdn1 = RDN((self.attr1, self.value1))
rdn2 = RDN((self.attr2, self.value2))
# in-place addtion
rdn1 += rdn2
self.assertEqual(rdn1, self.rdn3)
rdn1 = RDN((self.attr1, self.value1))
rdn1 += self.ava2
self.assertEqual(rdn1, self.rdn3)
rdn1 = RDN((self.attr1, self.value1))
rdn1 += self.str_ava2
self.assertEqual(rdn1, self.rdn3)
# concatenation
rdn1 = RDN((self.attr1, self.value1))
rdn3 = rdn1 + rdn2
self.assertEqual(rdn3, self.rdn3)
rdn3 = rdn1 + self.ava2
self.assertEqual(rdn3, self.rdn3)
rdn3 = rdn1 + self.str_ava2
self.assertEqual(rdn3, self.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 test_create(self):
# Create with single attr,value pair
dn1 = DN((self.attr1, self.value1))
self.assertEqual(len(dn1), 1)
self.assertIsInstance(dn1[0], RDN)
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((self.attr1, self.value1))
self.assertEqual(len(dn1), 1)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn1)
# Creation with multiple attr,value string pairs should fail
with self.assertRaises(ValueError):
dn1 = DN(self.attr1, self.value1, self.attr2, self.value2)
# Create with multiple attr,value pairs passed as tuples & lists
dn1 = DN((self.attr1, self.value1), [self.attr2, self.value2])
self.assertEqual(len(dn1), 2)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn1)
self.assertIsInstance(dn1[1], RDN)
self.assertIsInstance(dn1[1].attr, unicode)
self.assertIsInstance(dn1[1].value, unicode)
self.assertEqual(dn1[1], self.rdn2)
# Create with multiple attr,value pairs passed as tuple and RDN
dn1 = DN((self.attr1, self.value1), RDN((self.attr2, self.value2)))
self.assertEqual(len(dn1), 2)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn1)
self.assertIsInstance(dn1[1], RDN)
self.assertIsInstance(dn1[1].attr, unicode)
self.assertIsInstance(dn1[1].value, unicode)
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((self.attr2, self.value2), (self.attr1, self.value1))
self.assertEqual(len(dn1), 2)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn2)
self.assertIsInstance(dn1[1], RDN)
self.assertIsInstance(dn1[1].attr, unicode)
self.assertIsInstance(dn1[1].value, unicode)
self.assertEqual(dn1[1], self.rdn1)
# Create with single RDN object
dn1 = DN(self.rdn1)
self.assertEqual(len(dn1), 1)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn1)
# Create with multiple RDN objects, assure ordering is preserved.
dn1 = DN(self.rdn1, self.rdn2)
self.assertEqual(len(dn1), 2)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn1)
self.assertIsInstance(dn1[1], RDN)
self.assertIsInstance(dn1[1].attr, unicode)
self.assertIsInstance(dn1[1].value, unicode)
self.assertEqual(dn1[1], self.rdn2)
# Create with multiple RDN objects in different order, assure
# ordering is preserved.
dn1 = DN(self.rdn2, self.rdn1)
self.assertEqual(len(dn1), 2)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn2)
self.assertIsInstance(dn1[1], RDN)
self.assertIsInstance(dn1[1].attr, unicode)
self.assertIsInstance(dn1[1].value, unicode)
self.assertEqual(dn1[1], self.rdn1)
# Create with single string with 1 RDN
dn1 = DN(self.str_rdn1)
self.assertEqual(len(dn1), 1)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn1)
# Create with single string with 2 RDN's
dn1 = DN(self.str_dn3)
self.assertEqual(len(dn1), 2)
self.assertIsInstance(dn1[0], RDN)
self.assertIsInstance(dn1[0].attr, unicode)
self.assertIsInstance(dn1[0].value, unicode)
self.assertEqual(dn1[0], self.rdn1)
self.assertIsInstance(dn1[1], RDN)
self.assertIsInstance(dn1[1].attr, unicode)
self.assertIsInstance(dn1[1].value, unicode)
self.assertEqual(dn1[1], self.rdn2)
# Create with RDN, and 2 DN's (e.g. attr + container + base)
dn1 = DN((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):
self.assertEqual(str(self.dn1), self.str_dn1)
self.assertIsInstance(str(self.dn1), str)
self.assertEqual(str(self.dn2), self.str_dn2)
self.assertIsInstance(str(self.dn2), str)
self.assertEqual(str(self.dn3), self.str_dn3)
self.assertIsInstance(str(self.dn3), str)
def test_cmp(self):
# Equality
dn1 = DN((self.attr1, self.value1))
self.assertTrue(dn1 == self.dn1)
self.assertFalse(dn1 != self.dn1)
result = cmp(dn1, self.dn1)
self.assertEqual(result, 0)
# Make dn1's attr greater
dn1[0].attr = self.attr1 + "1"
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
dn1[0].attr = self.attr1
result = cmp(dn1, self.dn1)
self.assertEqual(result, 0)
# Make dn1's value greater
# attr will be equal, this tests secondary comparision component
dn1[0].value = 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
self.assertTrue(self.base_container_dn.startswith(self.rdn1))
self.assertTrue(self.base_container_dn.startswith(self.dn1))
self.assertTrue(self.base_container_dn.startswith(self.dn1 + self.container_dn))
self.assertFalse(self.base_container_dn.startswith(self.dn2))
self.assertFalse(self.base_container_dn.startswith(self.rdn2))
self.assertTrue(self.base_container_dn.startswith((self.dn1)))
self.assertTrue(self.base_container_dn.startswith((self.rdn1)))
self.assertFalse(self.base_container_dn.startswith((self.rdn2)))
self.assertTrue(self.base_container_dn.startswith((self.rdn2, self.rdn1)))
self.assertTrue(self.base_container_dn.startswith((self.dn1, self.dn2)))
self.assertTrue(self.base_container_dn.endswith(self.base_dn))
self.assertTrue(self.base_container_dn.endswith(self.container_dn + self.base_dn))
self.assertFalse(self.base_container_dn.endswith(DN(self.base_rdn1)))
self.assertTrue(self.base_container_dn.endswith(DN(self.base_rdn2)))
self.assertTrue(self.base_container_dn.endswith((DN(self.base_rdn1), DN(self.base_rdn2))))
# Test "in" membership
self.assertTrue(self.container_rdn1 in self.container_dn)
self.assertTrue(self.container_dn in self.container_dn)
self.assertFalse(self.base_rdn1 in self.container_dn)
self.assertTrue(self.container_rdn1 in self.base_container_dn)
self.assertTrue(self.container_dn in self.base_container_dn)
self.assertTrue(self.container_dn + self.base_dn in
self.base_container_dn)
self.assertTrue(self.dn1 + self.container_dn + self.base_dn in
self.base_container_dn)
self.assertTrue(self.dn1 + self.container_dn + self.base_dn ==
self.base_container_dn)
self.assertFalse(self.container_rdn1 in self.base_dn)
def test_indexing(self):
self.assertEqual(self.dn1[0], self.rdn1)
self.assertEqual(self.dn1[self.rdn1.attr], self.rdn1.value)
with self.assertRaises(KeyError):
self.dn1['foo']
self.assertEqual(self.dn2[0], self.rdn2)
self.assertEqual(self.dn2[self.rdn2.attr], self.rdn2.value)
with self.assertRaises(KeyError):
self.dn2['foo']
self.assertEqual(self.dn3[0], self.rdn1)
self.assertEqual(self.dn3[self.rdn1.attr], self.rdn1.value)
self.assertEqual(self.dn3[1], self.rdn2)
self.assertEqual(self.dn3[self.rdn2.attr], self.rdn2.value)
with self.assertRaises(KeyError):
self.dn3['foo']
with self.assertRaises(TypeError):
self.dn3[1.0]
def test_assignments(self):
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(*rdn_args)
rdn_args = make_rdn_args(dn_low, dn_high, 'list',
default_rdn_attr_arg, default_rdn_value_arg)
dn2 = DN(*rdn_args)
rdn_args = make_rdn_args(dn_low, dn_high, 'RDN',
default_rdn_attr_arg, default_rdn_value_arg)
dn3 = DN(*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)
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)
dn1[i] = attr, value
dn2[orig_attr] = (attr, value)
dn3[i] = RDN((attr, value))
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].value, dn1[i].value)
self.assertEqual(dn1[attr], value)
# Slices
slice_low = 2
slice_high = 4
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)
dn1 = DN(*rdn_args)
dn_slice = make_rdn_args(slice_low, slice_high, 'tuple',
alt_rdn_attr_arg, alt_rdn_value_arg)
dn1[slice_low:slice_high] = dn_slice
for i in range(dn_low, dn_high):
if i in 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(dn1[i].value, dn1[i].value)
self.assertEqual(dn1[attr], value)
query_slice = dn1[slice_low:slice_high]
for i, query_rdn in enumerate(query_slice):
slice_rdn = RDN(dn_slice[i])
self.assertEqual(slice_rdn, query_rdn)
# Slices
# Assign via RDN
rdn_args = make_rdn_args(dn_low, dn_high, 'tuple',
default_rdn_attr_arg, default_rdn_value_arg)
dn1 = DN(*rdn_args)
dn_slice = make_rdn_args(slice_low, slice_high, 'RDN',
alt_rdn_attr_arg, alt_rdn_value_arg)
dn1[slice_low:slice_high] = dn_slice
for i in range(dn_low, dn_high):
if i in 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(dn1[i].value, dn1[i].value)
self.assertEqual(dn1[attr], value)
query_slice = dn1[slice_low:slice_high]
for i, query_rdn in enumerate(query_slice):
slice_rdn = dn_slice[i]
self.assertEqual(slice_rdn, query_rdn)
def test_iter(self):
self.assertEqual(len(self.dn1), 1)
self.assertEqual(self.dn1[:], [self.rdn1])
for i, ava in enumerate(self.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(self.dn2), 1)
self.assertEqual(self.dn2[:], [self.rdn2])
for i, ava in enumerate(self.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(self.dn3), 2)
self.assertEqual(self.dn3[:], [self.rdn1, self.rdn2])
for i, ava in enumerate(self.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(self.dn3)))
def test_concat(self):
dn1 = DN((self.attr1, self.value1))
dn2 = DN([self.attr2, self.value2])
# in-place addtion
dn1 += dn2
self.assertEqual(dn1, self.dn3)
dn1 = DN((self.attr1, self.value1))
dn1 += self.rdn2
self.assertEqual(dn1, self.dn3)
dn1 = DN((self.attr1, self.value1))
dn1 += self.dn2
self.assertEqual(dn1, self.dn3)
dn1 = DN((self.attr1, self.value1))
dn1 += self.str_dn2
self.assertEqual(dn1, self.dn3)
# concatenation
dn1 = DN((self.attr1, self.value1))
dn3 = dn1 + dn2
self.assertEqual(dn3, self.dn3)
dn1 = DN((self.attr1, self.value1))
dn3 = dn1 + self.rdn2
self.assertEqual(dn3, self.dn3)
dn3 = dn1 + self.str_rdn2
self.assertEqual(dn3, self.dn3)
dn3 = dn1 + self.str_dn2
self.assertEqual(dn3, self.dn3)
dn3 = dn1 + self.dn2
self.assertEqual(dn3, self.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):
dn = DN(self.dn_str_hex_escape)
self.assertEqual(dn['cn'], self.privilege)
self.assertEqual(dn[0].value, self.privilege)
dn = DN(self.dn_str_backslash_escape)
self.assertEqual(dn['cn'], self.privilege)
self.assertEqual(dn[0].value, self.privilege)
if __name__ == '__main__':
unittest.main()
Reference in new issue View Git Blame Copy Permalink