diff options
author | John Dennis <jdennis@redhat.com> | 2011-07-20 19:39:05 -0400 |
---|---|---|
committer | Rob Crittenden <rcritten@redhat.com> | 2011-07-21 00:29:38 -0400 |
commit | ad3cf68ac222bb288945e7e3d1c549ce8b49c02c (patch) | |
tree | 7f123ef8012812f4a25eaa8a9f3457ac1f032d58 /tests | |
parent | d4310c07a9454289676b17d6224ae7b62c51c207 (diff) | |
download | freeipa-ad3cf68ac222bb288945e7e3d1c549ce8b49c02c.tar.gz freeipa-ad3cf68ac222bb288945e7e3d1c549ce8b49c02c.tar.xz freeipa-ad3cf68ac222bb288945e7e3d1c549ce8b49c02c.zip |
Ticket 1485 - DN pairwise grouping
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
Diffstat (limited to 'tests')
-rw-r--r--[-rwxr-xr-x] | tests/test_ipalib/test_dn.py | 184 | ||||
-rw-r--r-- | tests/test_xmlrpc/test_role_plugin.py | 2 |
2 files changed, 117 insertions, 69 deletions
diff --git a/tests/test_ipalib/test_dn.py b/tests/test_ipalib/test_dn.py index c47f38827..029297f69 100755..100644 --- a/tests/test_ipalib/test_dn.py +++ b/tests/test_ipalib/test_dn.py @@ -3,27 +3,36 @@ 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 = 'a%d' % i + new_attr = default_rdn_attr_arg(i) elif callable(attr): new_attr = attr(i) else: new_attr = attr if value is None: - new_value = str(i) + new_value = default_rdn_value_arg(i) elif callable(value): new_value = value(i) else: new_value = value - if kind == 'sequence': - result.append(new_attr) - result.append(new_value) - elif kind == 'tuple': + if kind == 'tuple': result.append((new_attr, new_value)) elif kind == 'list': result.append([new_attr, new_value]) @@ -526,9 +535,21 @@ class TestDN(unittest.TestCase): 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) + dn1 = DN((self.attr1, self.value1)) self.assertEqual(len(dn1), 1) self.assertIsInstance(dn1[0], RDN) self.assertIsInstance(dn1[0].attr, unicode) @@ -543,8 +564,12 @@ class TestDN(unittest.TestCase): self.assertIsInstance(dn1[0].value, unicode) self.assertEqual(dn1[0], self.rdn1) - # Create with multiple attr,value pairs - dn1 = DN(self.attr1, self.value1, self.attr2, self.value2) + # 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) @@ -555,8 +580,8 @@ class TestDN(unittest.TestCase): self.assertIsInstance(dn1[1].value, unicode) self.assertEqual(dn1[1], self.rdn2) - # Create with multiple attr,value pairs passed as lists - dn1 = DN([self.attr1, self.value1], [self.attr2, self.value2]) + # 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) @@ -570,7 +595,7 @@ class TestDN(unittest.TestCase): # 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) + 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) @@ -634,6 +659,14 @@ class TestDN(unittest.TestCase): 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) @@ -646,7 +679,7 @@ class TestDN(unittest.TestCase): def test_cmp(self): # Equality - dn1 = DN(self.attr1, self.value1) + dn1 = DN((self.attr1, self.value1)) self.assertTrue(dn1 == self.dn1) self.assertFalse(dn1 != self.dn1) @@ -688,6 +721,40 @@ class TestDN(unittest.TestCase): 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) @@ -713,30 +780,33 @@ class TestDN(unittest.TestCase): dn_low = 0 dn_high = 6 - rdn_args = make_rdn_args(dn_low, dn_high, 'sequence') + 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, 'tuple') + 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') + 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 = 'a%d' % i - value = str(i) + 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 = 'a%d' % i - attr = 'b%d' % i - value = str(i*10) + 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) @@ -746,11 +816,11 @@ class TestDN(unittest.TestCase): for i in range(dn_low, dn_high): if i % 2: - attr = 'b%d' % i - value = str(i*10) + attr = alt_rdn_attr_arg(i) + value = alt_rdn_value_arg(i) else: - attr = 'a%d' % i - value = str(i) + 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) @@ -759,47 +829,24 @@ class TestDN(unittest.TestCase): slice_high = 4 interval = range(slice_low, slice_high) - # Assign via sequence - rdn_args = make_rdn_args(dn_low, dn_high, 'sequence') - dn1 = DN(*rdn_args) - - dn_slice = make_rdn_args(slice_low, slice_high, 'sequence', - lambda i: 'b%d' % i, lambda i: str(i*10)) - - dn1[slice_low:slice_high] = dn_slice - - for i in range(dn_low, dn_high): - if i in interval: - attr = 'b%d' % i - value = str(i*10) - else: - attr = 'a%d' % i - value = str(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*2], dn_slice[i*2+1]) - self.assertEqual(slice_rdn, query_rdn) - # Slices # Assign via tuple - rdn_args = make_rdn_args(dn_low, dn_high, 'sequence') + 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', - lambda i: 'b%d' % i, lambda i: str(i*10)) + 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 = 'b%d' % i - value = str(i*10) + attr = alt_rdn_attr_arg(i) + value = alt_rdn_value_arg(i) else: - attr = 'a%d' % i - value = str(i) + 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) @@ -810,21 +857,22 @@ class TestDN(unittest.TestCase): # Slices # Assign via RDN - rdn_args = make_rdn_args(dn_low, dn_high, 'sequence') + 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', - lambda i: 'b%d' % i, lambda i: str(i*10)) + 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 = 'b%d' % i - value = str(i*10) + attr = alt_rdn_attr_arg(i) + value = alt_rdn_value_arg(i) else: - attr = 'a%d' % i - value = str(i) + 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) @@ -863,31 +911,31 @@ class TestDN(unittest.TestCase): def test_concat(self): - dn1 = DN(self.attr1, self.value1) - dn2 = DN(self.attr2, self.value2) + 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 = DN((self.attr1, self.value1)) dn1 += self.rdn2 self.assertEqual(dn1, self.dn3) - dn1 = DN(self.attr1, self.value1) + dn1 = DN((self.attr1, self.value1)) dn1 += self.dn2 self.assertEqual(dn1, self.dn3) - dn1 = DN(self.attr1, self.value1) + dn1 = DN((self.attr1, self.value1)) dn1 += self.str_dn2 self.assertEqual(dn1, self.dn3) # concatenation - dn1 = DN(self.attr1, self.value1) + dn1 = DN((self.attr1, self.value1)) dn3 = dn1 + dn2 self.assertEqual(dn3, self.dn3) - dn1 = DN(self.attr1, self.value1) + dn1 = DN((self.attr1, self.value1)) dn3 = dn1 + self.rdn2 self.assertEqual(dn3, self.dn3) diff --git a/tests/test_xmlrpc/test_role_plugin.py b/tests/test_xmlrpc/test_role_plugin.py index 82342c340..e1485cf42 100644 --- a/tests/test_xmlrpc/test_role_plugin.py +++ b/tests/test_xmlrpc/test_role_plugin.py @@ -44,7 +44,7 @@ group1 = u'testgroup1' group1_dn = u'cn=%s,%s,%s' % (group1, api.env.container_group, api.env.basedn) privilege1 = u'r,w privilege 1' -privilege1_dn = DN('cn', privilege1, DN(api.env.container_privilege), DN(api.env.basedn)) +privilege1_dn = DN(('cn', privilege1), DN(api.env.container_privilege), DN(api.env.basedn)) def escape_comma(value): return value.replace(',', '\\,') |