mirror of
https://salsa.debian.org/freeipa-team/freeipa.git
synced 2025-02-25 18:55:28 -06:00
ad3cf68ac2
The pairwise grouping used to form RDN's and AVA's proved to be confusing in practice, this patch removes that functionality thus requiring programmers to explicitly pair attr,value using a tuple or list. In addition it was discovered additional functionality was needed to support some DN operations in freeipa. DN objects now support startswith(), endswith() and the "in" membership test. These functions and operators will accept either a DN or RDN. The unittest was modified to remove the pairwise tests and add new explicit tests. The unittest was augmented to test the new functionality. In addition the unittest was cleaned up a bit to use common utilty functions for improved readabilty and robustness. The documentation was updated. fix test_role_plugin use of DN to avoid pairwise grouping
968 lines
34 KiB
Python
968 lines
34 KiB
Python
#!/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)
|
|
|
|
# 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 single attr,value pair passed as a tuple
|
|
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()
|