mirror of
https://salsa.debian.org/freeipa-team/freeipa.git
synced 2025-02-25 18:55:28 -06:00
0a64e9bd70
Web UI tests were marked as tier1 tests.
The tier system is intended to be used together with CI system
to make sure the more complicated tests are being run only
when all of the basic functionality is working.
The system is using pytest's marker system. E.g. an invocation of
all tier1 tests with listing will look like:
$ py.test -v -m tier1 ipatests
or in case of out of tree tests:
$ ipa-run-tests -m tier1
Reviewed-By: Ales 'alich' Marecek <amarecek@redhat.com>
1308 lines
46 KiB
Python
1308 lines
46 KiB
Python
import contextlib
|
|
import unittest
|
|
import pytest
|
|
from ipapython.dn import * # FIXME
|
|
|
|
import six
|
|
|
|
from ipapython.dn import DN, RDN, AVA
|
|
|
|
if six.PY3:
|
|
unicode = str
|
|
|
|
def cmp(a, b):
|
|
if a == b:
|
|
assert not a < b
|
|
assert not a > b
|
|
assert not a != b
|
|
assert a <= b
|
|
assert a >= b
|
|
return 0
|
|
elif a < b:
|
|
assert not a > b
|
|
assert a != b
|
|
assert a <= b
|
|
assert not a >= b
|
|
return -1
|
|
else:
|
|
assert a > b
|
|
assert a != b
|
|
assert not a <= b
|
|
assert a >= b
|
|
return 1
|
|
|
|
pytestmark = pytest.mark.tier0
|
|
|
|
|
|
def expected_class(klass, component):
|
|
if klass is AVA:
|
|
if component == 'self':
|
|
return AVA
|
|
|
|
elif klass is RDN:
|
|
if component == 'self':
|
|
return RDN
|
|
elif component == 'AVA':
|
|
return AVA
|
|
|
|
elif klass is DN:
|
|
if component == 'self':
|
|
return DN
|
|
elif component == 'AVA':
|
|
return AVA
|
|
elif component == 'RDN':
|
|
return RDN
|
|
|
|
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):
|
|
# Create with attr,value pair
|
|
ava1 = AVA(self.attr1, self.value1)
|
|
self.assertExpectedClass(AVA, ava1, 'self')
|
|
self.assertEqual(ava1, self.ava1)
|
|
|
|
# Create with "attr=value" string
|
|
ava1 = AVA(self.str_ava1)
|
|
self.assertExpectedClass(AVA, ava1, 'self')
|
|
self.assertEqual(ava1, self.ava1)
|
|
|
|
# Create with tuple (attr, value)
|
|
ava1 = AVA((self.attr1, self.value1))
|
|
self.assertExpectedClass(AVA, ava1, 'self')
|
|
self.assertEqual(ava1, self.ava1)
|
|
|
|
# Create with list [attr, value]
|
|
ava1 = AVA([self.attr1, self.value1])
|
|
self.assertExpectedClass(AVA, ava1, 'self')
|
|
self.assertEqual(ava1, self.ava1)
|
|
|
|
# Create with no args should fail
|
|
with self.assertRaises(TypeError):
|
|
AVA()
|
|
|
|
# Create with more than 3 args should fail
|
|
with self.assertRaises(TypeError):
|
|
AVA(self.attr1, self.value1, self.attr1, 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 convert
|
|
ava1 = AVA(1, self.value1)
|
|
self.assertExpectedClass(AVA, ava1, 'self')
|
|
self.assertEqual(ava1.attr, u'1')
|
|
|
|
ava1 = AVA((1, self.value1))
|
|
self.assertExpectedClass(AVA, ava1, 'self')
|
|
self.assertEqual(ava1.attr, u'1')
|
|
|
|
ava1 = AVA(self.attr1, 1)
|
|
self.assertExpectedClass(AVA, ava1, 'self')
|
|
self.assertEqual(ava1.value, u'1')
|
|
|
|
ava1 = AVA((self.attr1, 1))
|
|
self.assertExpectedClass(AVA, ava1, 'self')
|
|
self.assertEqual(ava1.value, u'1')
|
|
|
|
def test_indexing(self):
|
|
ava1 = AVA(self.ava1)
|
|
|
|
self.assertEqual(ava1[self.attr1], self.value1)
|
|
|
|
self.assertEqual(ava1[0], self.attr1)
|
|
self.assertEqual(ava1[1], self.value1)
|
|
|
|
with self.assertRaises(KeyError):
|
|
ava1['foo']
|
|
|
|
with self.assertRaises(KeyError):
|
|
ava1[3]
|
|
|
|
def test_properties(self):
|
|
ava1 = AVA(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):
|
|
ava1 = AVA(self.ava1)
|
|
|
|
self.assertEqual(str(ava1), self.str_ava1)
|
|
self.assertIsInstance(str(ava1), str)
|
|
|
|
def test_cmp(self):
|
|
# Equality
|
|
ava1 = AVA(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(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
|
|
with self.assertRaises(AttributeError):
|
|
ava1.attr = self.attr1 + "1"
|
|
ava1 = AVA(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
|
|
with self.assertRaises(AttributeError):
|
|
ava1.attr = self.attr1
|
|
ava1 = AVA(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
|
|
with self.assertRaises(AttributeError):
|
|
ava1.value = self.value1 + "1"
|
|
ava1 = AVA(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
|
|
ava1 = AVA((self.attr1.lower(), self.value1.upper()))
|
|
ava2 = AVA((self.attr1.upper(), self.value1.lower()))
|
|
|
|
# AVAs that are equal should hash to the same value.
|
|
self.assertEqual(ava1, ava2)
|
|
self.assertEqual(hash(ava1), hash(ava2))
|
|
|
|
# Different 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.
|
|
|
|
ava1_a = AVA(self.ava1)
|
|
ava1_b = AVA(self.ava1)
|
|
|
|
ava2_a = AVA(self.ava2)
|
|
ava2_b = AVA(self.ava2)
|
|
|
|
ava3_a = AVA(self.ava3)
|
|
ava3_b = AVA(self.ava3)
|
|
|
|
self.assertEqual(ava1_a, ava1_b)
|
|
self.assertEqual(ava2_a, ava2_b)
|
|
self.assertEqual(ava3_a, ava3_b)
|
|
|
|
d = dict()
|
|
s = set()
|
|
|
|
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), 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(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)
|
|
|
|
|
|
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):
|
|
# Create with single attr,value pair
|
|
rdn1 = RDN((self.attr1, self.value1))
|
|
|
|
|
|
self.assertEqual(len(rdn1), 1)
|
|
self.assertEqual(rdn1, self.rdn1)
|
|
self.assertExpectedClass(RDN, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN, rdn1[i], '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.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, 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([self.attr1, self.value1], [self.attr2, self.value2])
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, 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((self.attr2, self.value2), (self.attr1, self.value1))
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
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.assertExpectedClass(RDN, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN, rdn1[i], '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.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, 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(self.ava2, self.ava1)
|
|
self.assertEqual(len(rdn3), 2)
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
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.assertExpectedClass(RDN, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN, rdn1[i], '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.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, rdn3[i], 'AVA')
|
|
self.assertEqual(rdn3[0], self.ava1)
|
|
self.assertEqual(rdn3[1], self.ava2)
|
|
|
|
def test_properties(self):
|
|
rdn1 = RDN(self.rdn1)
|
|
rdn2 = RDN(self.rdn2)
|
|
rdn3 = RDN(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):
|
|
rdn1 = RDN(self.rdn1)
|
|
rdn2 = RDN(self.rdn2)
|
|
rdn3 = RDN(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):
|
|
# Equality
|
|
rdn1 = RDN((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
|
|
rdn1 = RDN((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
|
|
rdn1 = RDN((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
|
|
rdn1 = RDN((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):
|
|
rdn1 = RDN(self.rdn1)
|
|
rdn2 = RDN(self.rdn2)
|
|
rdn3 = RDN(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):
|
|
rdn = RDN((self.attr1, self.value1))
|
|
with self.assertRaises(TypeError):
|
|
rdn[0] = self.ava2
|
|
|
|
def test_iter(self):
|
|
rdn1 = RDN(self.rdn1)
|
|
rdn2 = RDN(self.rdn2)
|
|
rdn3 = RDN(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):
|
|
rdn1 = RDN((self.attr1, self.value1))
|
|
rdn2 = RDN((self.attr2, self.value2))
|
|
|
|
# in-place addtion
|
|
rdn1 += rdn2
|
|
self.assertEqual(rdn1, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN, rdn1[i], 'AVA')
|
|
|
|
rdn1 = RDN((self.attr1, self.value1))
|
|
rdn1 += self.ava2
|
|
self.assertEqual(rdn1, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN, rdn1[i], 'AVA')
|
|
|
|
rdn1 = RDN((self.attr1, self.value1))
|
|
rdn1 += self.str_ava2
|
|
self.assertEqual(rdn1, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn1, 'self')
|
|
for i in range(0, len(rdn1)):
|
|
self.assertExpectedClass(RDN, rdn1[i], 'AVA')
|
|
|
|
# concatenation
|
|
rdn1 = RDN((self.attr1, self.value1))
|
|
rdn3 = rdn1 + rdn2
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, rdn3[i], 'AVA')
|
|
|
|
rdn3 = rdn1 + self.ava2
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, rdn3[i], 'AVA')
|
|
|
|
rdn3 = rdn1 + self.str_ava2
|
|
self.assertEqual(rdn3, self.rdn3)
|
|
self.assertExpectedClass(RDN, rdn3, 'self')
|
|
for i in range(0, len(rdn3)):
|
|
self.assertExpectedClass(RDN, rdn3[i], 'AVA')
|
|
|
|
|
|
def test_hashing(self):
|
|
# create RDN's that are equal but differ in case
|
|
rdn1 = RDN((self.attr1.lower(), self.value1.upper()))
|
|
rdn2 = RDN((self.attr1.upper(), self.value1.lower()))
|
|
|
|
# RDNs that are equal should hash to the same value.
|
|
self.assertEqual(rdn1, rdn2)
|
|
self.assertEqual(hash(rdn1), hash(rdn2))
|
|
|
|
|
|
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):
|
|
# Create with single attr,value pair
|
|
dn1 = DN((self.attr1, self.value1))
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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((self.attr1, self.value1))
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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(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.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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((self.attr1, self.value1), RDN((self.attr2, self.value2)))
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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((self.attr2, self.value2), (self.attr1, self.value1))
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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(self.rdn1)
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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(self.rdn1, self.rdn2)
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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(self.rdn2, self.rdn1)
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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(self.str_rdn1)
|
|
self.assertEqual(len(dn1), 1)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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(self.str_dn3)
|
|
self.assertEqual(len(dn1), 2)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, 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((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):
|
|
dn1 = DN(self.dn1)
|
|
dn2 = DN(self.dn2)
|
|
dn3 = DN(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):
|
|
# Equality
|
|
dn1 = DN((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
|
|
with self.assertRaises(AttributeError):
|
|
dn1[0].attr = self.attr1 + "1"
|
|
dn1 = DN((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
|
|
with self.assertRaises(AttributeError):
|
|
dn1[0].attr = self.attr1
|
|
dn1 = DN((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
|
|
with self.assertRaises(AttributeError):
|
|
dn1[0].value = self.value1 + "1"
|
|
dn1 = DN((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(self.container_dn)
|
|
base_container_dn = DN(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):
|
|
dn1 = DN(self.dn1)
|
|
dn2 = DN(self.dn2)
|
|
dn3 = DN(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):
|
|
dn = dn2 = DN('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=8,t=9')
|
|
with self.assertRaises(TypeError):
|
|
dn[0] = RDN('t=a')
|
|
with self.assertRaises(TypeError):
|
|
dn[0:1] = [RDN('t=a'), RDN('t=b')]
|
|
|
|
def test_iter(self):
|
|
dn1 = DN(self.dn1)
|
|
dn2 = DN(self.dn2)
|
|
dn3 = DN(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[:], DN(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):
|
|
dn1 = DN((self.attr1, self.value1))
|
|
dn2 = DN([self.attr2, self.value2])
|
|
|
|
# in-place addtion
|
|
|
|
dn1 += dn2
|
|
self.assertEqual(dn1, self.dn3)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, dn1[i][j], 'AVA')
|
|
|
|
|
|
dn1 = DN((self.attr1, self.value1))
|
|
dn1 += self.rdn2
|
|
self.assertEqual(dn1, self.dn3)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, dn1[i][j], 'AVA')
|
|
|
|
|
|
dn1 = DN((self.attr1, self.value1))
|
|
dn1 += self.dn2
|
|
self.assertEqual(dn1, self.dn3)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, dn1[i][j], 'AVA')
|
|
|
|
|
|
dn1 = DN((self.attr1, self.value1))
|
|
dn1 += self.str_dn2
|
|
self.assertEqual(dn1, self.dn3)
|
|
self.assertExpectedClass(DN, dn1, 'self')
|
|
for i in range(0, len(dn1)):
|
|
self.assertExpectedClass(DN, dn1[i], 'RDN')
|
|
for j in range(0, len(dn1[i])):
|
|
self.assertExpectedClass(DN, dn1[i][j], 'AVA')
|
|
|
|
|
|
# concatenation
|
|
dn1 = DN((self.attr1, self.value1))
|
|
dn3 = dn1 + dn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN, dn3[i][j], 'AVA')
|
|
|
|
|
|
dn1 = DN((self.attr1, self.value1))
|
|
dn3 = dn1 + self.rdn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN, dn3[i][j], 'AVA')
|
|
|
|
dn3 = dn1 + self.str_rdn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN, dn3[i], 'RDN')
|
|
self.assertExpectedClass(DN, dn3[i][0], 'AVA')
|
|
|
|
dn3 = dn1 + self.str_dn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN, dn3, 'self')
|
|
self.assertExpectedClass(DN, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN, dn3[i][j], 'AVA')
|
|
|
|
dn3 = dn1 + self.dn2
|
|
self.assertEqual(dn3, self.dn3)
|
|
self.assertExpectedClass(DN, dn3, 'self')
|
|
self.assertExpectedClass(DN, dn3, 'self')
|
|
for i in range(0, len(dn3)):
|
|
self.assertExpectedClass(DN, dn3[i], 'RDN')
|
|
for j in range(0, len(dn3[i])):
|
|
self.assertExpectedClass(DN, dn3[i][j], 'AVA')
|
|
|
|
def test_find(self):
|
|
# -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
|
|
dn = DN('t=0,t=1,cn=bob,t=3,t=4,t=5,cn=bob,t=7,t=8,t=9')
|
|
pat = DN('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):
|
|
# pylint: disable=no-member
|
|
dn = DN('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=8,t=9')
|
|
with self.assertRaises(AttributeError):
|
|
dn.replace
|
|
|
|
def test_hashing(self):
|
|
# create DN's that are equal but differ in case
|
|
dn1 = DN((self.attr1.lower(), self.value1.upper()))
|
|
dn2 = DN((self.attr1.upper(), self.value1.lower()))
|
|
|
|
# DNs that are equal should hash to the same value.
|
|
self.assertEqual(dn1, dn2)
|
|
|
|
# Good, everyone's equal, now verify their hash values
|
|
|
|
self.assertEqual(hash(dn1), hash(dn2))
|
|
|
|
# Different 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.
|
|
|
|
dn1_a = DN(self.dn1)
|
|
dn1_b = DN(self.dn1)
|
|
|
|
dn2_a = DN(self.dn2)
|
|
dn2_b = DN(self.dn2)
|
|
|
|
dn3_a = DN(self.dn3)
|
|
dn3_b = DN(self.dn3)
|
|
|
|
self.assertEqual(dn1_a, dn1_b)
|
|
self.assertEqual(dn2_a, dn2_b)
|
|
self.assertEqual(dn3_a, dn3_b)
|
|
|
|
d = dict()
|
|
s = set()
|
|
|
|
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), 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(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)
|
|
|
|
|
|
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)
|
|
|
|
class TestInternationalization(unittest.TestCase):
|
|
def setUp(self):
|
|
# Hello in Arabic
|
|
self.arabic_hello_utf8 = (b'\xd9\x85\xd9\x83\xd9\x8a\xd9\x84' +
|
|
b'\xd8\xb9\x20\xd9\x85\xd8\xa7\xd9' +
|
|
b'\x84\xd9\x91\xd8\xb3\xd9\x84\xd8\xa7')
|
|
|
|
self.arabic_hello_unicode = self.arabic_hello_utf8.decode('utf-8')
|
|
|
|
def assert_equal_utf8(self, obj, b):
|
|
if six.PY2:
|
|
self.assertEqual(str(obj), b)
|
|
else:
|
|
self.assertEqual(str(obj), b.decode('utf-8'))
|
|
|
|
@contextlib.contextmanager
|
|
def fail_py3(self, exception_type):
|
|
try:
|
|
yield
|
|
except exception_type:
|
|
if six.PY2:
|
|
raise
|
|
|
|
def test_i18n(self):
|
|
self.assertEqual(self.arabic_hello_utf8,
|
|
self.arabic_hello_unicode.encode('utf-8'))
|
|
|
|
# AVA's
|
|
# test attr i18n
|
|
ava1 = AVA(self.arabic_hello_unicode, 'foo')
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
self.assertEqual(ava1.attr, self.arabic_hello_unicode)
|
|
self.assert_equal_utf8(ava1, self.arabic_hello_utf8 + b'=foo')
|
|
|
|
with self.fail_py3(TypeError):
|
|
ava1 = AVA(self.arabic_hello_utf8, 'foo')
|
|
if six.PY2:
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
self.assertEqual(ava1.attr, self.arabic_hello_unicode)
|
|
self.assert_equal_utf8(ava1, self.arabic_hello_utf8 + b'=foo')
|
|
|
|
# test value i18n
|
|
ava1 = AVA('cn', self.arabic_hello_unicode)
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
self.assertEqual(ava1.value, self.arabic_hello_unicode)
|
|
self.assert_equal_utf8(ava1, b'cn=' + self.arabic_hello_utf8)
|
|
|
|
with self.fail_py3(TypeError):
|
|
ava1 = AVA('cn', self.arabic_hello_utf8)
|
|
if six.PY2:
|
|
self.assertIsInstance(ava1.attr, unicode)
|
|
self.assertIsInstance(ava1.value, unicode)
|
|
self.assertEqual(ava1.value, self.arabic_hello_unicode)
|
|
self.assert_equal_utf8(ava1, b'cn=' + self.arabic_hello_utf8)
|
|
|
|
# RDN's
|
|
# test attr i18n
|
|
rdn1 = RDN((self.arabic_hello_unicode, 'foo'))
|
|
self.assertIsInstance(rdn1.attr, unicode)
|
|
self.assertIsInstance(rdn1.value, unicode)
|
|
self.assertEqual(rdn1.attr, self.arabic_hello_unicode)
|
|
self.assert_equal_utf8(rdn1, self.arabic_hello_utf8 + b'=foo')
|
|
|
|
with self.fail_py3(TypeError):
|
|
rdn1 = RDN((self.arabic_hello_utf8, 'foo'))
|
|
if six.PY2:
|
|
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 + b'=foo')
|
|
|
|
# test value i18n
|
|
rdn1 = RDN(('cn', self.arabic_hello_unicode))
|
|
self.assertIsInstance(rdn1.attr, unicode)
|
|
self.assertIsInstance(rdn1.value, unicode)
|
|
self.assertEqual(rdn1.value, self.arabic_hello_unicode)
|
|
self.assert_equal_utf8(rdn1, b'cn=' + self.arabic_hello_utf8)
|
|
|
|
with self.fail_py3(TypeError):
|
|
rdn1 = RDN(('cn', self.arabic_hello_utf8))
|
|
if six.PY2:
|
|
self.assertIsInstance(rdn1.attr, unicode)
|
|
self.assertIsInstance(rdn1.value, unicode)
|
|
self.assertEqual(rdn1.value, self.arabic_hello_unicode)
|
|
self.assertEqual(str(rdn1), b'cn=' + self.arabic_hello_utf8)
|
|
|
|
# DN's
|
|
# test attr i18n
|
|
dn1 = DN((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.assert_equal_utf8(dn1, self.arabic_hello_utf8 + b'=foo')
|
|
|
|
with self.fail_py3(TypeError):
|
|
dn1 = DN((self.arabic_hello_utf8, 'foo'))
|
|
if six.PY2:
|
|
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 + b'=foo')
|
|
|
|
# test value i18n
|
|
dn1 = DN(('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.assert_equal_utf8(dn1, b'cn=' + self.arabic_hello_utf8)
|
|
|
|
with self.fail_py3(TypeError):
|
|
dn1 = DN(('cn', self.arabic_hello_utf8))
|
|
if six.PY2:
|
|
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), b'cn=' + self.arabic_hello_utf8)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|