def test_referencing(self):
# Serialize and deserialize references
node = AttributedNode()
node.attrs['func'] = referenced_function
node.attrs['class'] = ReferencedClass
node.attrs['method'] = ReferencedClass.foo
json_data = serialize(node)
data = json.loads(json_data)
self.assertEqual(list(data.keys()), ['__node__'])
node_data = data['__node__']
self.assertEqual(list(sorted(node_data.keys())),
['attrs', 'class', 'name'])
self.assertEqual(node_data['class'], 'node.base.AttributedNode')
self.assertEqual(node_data['name'], None)
attrs_data = node_data['attrs']
self.assertEqual(list(sorted(attrs_data.keys())),
['class', 'func', 'method'])
self.assertEqual(attrs_data['class']['__ob__'],
'node.tests.test_serializer.ReferencedClass')
self.assertEqual(attrs_data['func']['__ob__'],
'node.tests.test_serializer.referenced_function')
self.assertEqual(attrs_data['method']['__ob__'],
'node.tests.test_serializer.ReferencedClass.foo')
node = deserialize(json_data)
expected = '<AttributedNode object \'None\' at'
self.assertTrue(str(node).startswith(expected))
self.assertEqual(node.attrs['func'], referenced_function)
self.assertEqual(node.attrs['class'], ReferencedClass)
self.assertEqual(node.attrs['method'], ReferencedClass.foo)
def test_LDAPRelationFilter(self):
# LDAPRelationFilter inherits from LDAPFilter and provides creating
# LDAP filters from relations.
node = AttributedNode()
node.attrs['someUid'] = '123ä'
node.attrs['someName'] = 'Name'
rel_filter = LDAPRelationFilter(node, '')
self.assertEqual(str(rel_filter), '')
rel_filter = LDAPRelationFilter(node, 'someUid:otherUid')
rel_filter
self.assertEqual(str(rel_filter), '(otherUid=123ä)')
rel_filter = LDAPRelationFilter(
node,
'someUid:otherUid|someName:otherName'
)
self.assertEqual(
str(rel_filter),
'(|(otherName=Name)(otherUid=123ä))'
)
rel_filter &= LDAPFilter('(objectClass=person)')
self.assertEqual(
str(rel_filter),
'(&(|(otherName=Name)(otherUid=123ä))(objectClass=person))'
)
rel_filter = LDAPRelationFilter(
node,
'someUid:otherUid|someName:otherName',
False
)
self.assertEqual(
str(rel_filter),
'(&(otherName=Name)(otherUid=123ä))'
)
rel_filter = LDAPRelationFilter(
node,
'someUid:otherUid|someUid:otherName',
False
)
self.assertEqual(
str(rel_filter),
'(&(otherName=123ä)(otherUid=123ä))'
)
rel_filter = LDAPRelationFilter(
node,
'someUid:otherUid|inexistent:inexistent'
)
self.assertEqual(str(rel_filter), '(otherUid=123ä)')
def save(self, widget, data):
group = AttributedNode()
id = data.fetch('groupform.name').extracted
groups = self.model.__parent__.ldap_groups
self.request.environ['next_resource'] = id
groups[id] = group
groups.context()
self.model.__parent__.invalidate()
def save(self, widget, data):
settings = self.model.root['settings']
attrmap = settings.attrs.users_form_attrmap
user = AttributedNode()
for key, val in attrmap.items():
val = data.fetch('userform.%s' % key).extracted
if not val:
continue
user.attrs[key] = val
users = self.model.__parent__.ldap_users
id = user.attrs['id']
self.request.environ['next_resource'] = id
users[id] = user
users.context()
self.model.__parent__.invalidate()
password = data.fetch('userform.userPassword').extracted
if password is not UNSET:
users.passwd(id, None, password)
def save(self, widget, data):
settings = self.model.root['settings']
attrmap = settings.attrs.users_form_attrmap
user = AttributedNode()
for key, val in attrmap.items():
val = data.fetch('userform.%s' % key).extracted
if not val:
continue
user.attrs[key] = val
users = self.model.__parent__.ldap_users
id = user.attrs['id']
self.request.environ['next_resource'] = id
users[id] = user
users.context()
self.model.__parent__.invalidate()
password = data.fetch('userform.userPassword').extracted
if password is not UNSET:
users.passwd(id, None, password)
def __setitem__(self, name, vessel):
try:
attrs = vessel.attrs
except AttributeError:
raise ValueError(u"no attributes found, cannot convert.")
if name in self:
raise KeyError(u"Key already exists: '%s'." % (name,))
nextvessel = AttributedNode()
nextvessel.__name__ = name
nextvessel.attribute_access_for_attrs = False
principal = self.principal_factory(
nextvessel,
attraliaser=self.principal_attraliaser)
principal.__name__ = name
principal.__parent__ = self
# XXX: cache
for key, val in attrs.iteritems():
principal.attrs[key] = val
self.context[name] = nextvessel
def test_referencing(self):
# Serialize and deserialize references
node = AttributedNode()
node.attrs['func'] = referenced_function
node.attrs['class'] = ReferencedClass
node.attrs['method'] = ReferencedClass.foo
json_data = serialize(node)
data = json.loads(json_data)
self.assertEqual(list(data.keys()), ['__node__'])
node_data = data['__node__']
self.assertEqual(
list(sorted(node_data.keys())),
['attrs', 'class', 'name']
)
self.assertEqual(node_data['class'], 'node.base.AttributedNode')
self.assertEqual(node_data['name'], None)
attrs_data = node_data['attrs']
self.assertEqual(
list(sorted(attrs_data.keys())),
['class', 'func', 'method']
)
self.assertEqual(
attrs_data['class']['__ob__'],
'node.tests.test_serializer.ReferencedClass'
)
self.assertEqual(
attrs_data['func']['__ob__'],
'node.tests.test_serializer.referenced_function'
)
self.assertEqual(
attrs_data['method']['__ob__'],
'node.tests.test_serializer.ReferencedClass.foo'
)
node = deserialize(json_data)
expected = '<AttributedNode object \'None\' at'
self.assertTrue(str(node).startswith(expected))
self.assertEqual(node.attrs['func'], referenced_function)
self.assertEqual(node.attrs['class'], ReferencedClass)
self.assertEqual(node.attrs['method'], ReferencedClass.foo)
def __setitem__(self, name, vessel):
"""XXX: mechanism for defining a target container if search scope is
SUBTREE
"""
try:
attrs = vessel.attrs
except AttributeError:
raise ValueError(u"no attributes found, cannot convert.")
if name in self:
raise KeyError(u"Key already exists: '%s'." % (name, ))
nextvessel = AttributedNode()
nextvessel.__name__ = name
nextvessel.attribute_access_for_attrs = False
principal = self.principal_factory(
nextvessel, attraliaser=self.principal_attraliaser)
principal.__name__ = name
principal.__parent__ = self
# XXX: cache
for key, val in attrs.iteritems():
principal.attrs[key] = val
self.context[name] = nextvessel
def test_LDAPRelationFilter(self):
# LDAPRelationFilter inherits from LDAPFilter and provides creating
# LDAP filters from relations.
node = AttributedNode()
node.attrs['someUid'] = '123ä'
node.attrs['someName'] = 'Name'
rel_filter = LDAPRelationFilter(node, '')
self.assertEqual(str(rel_filter), '')
rel_filter = LDAPRelationFilter(node, 'someUid:otherUid')
rel_filter
self.assertEqual(str(rel_filter), '(otherUid=123ä)')
rel_filter = LDAPRelationFilter(node,
'someUid:otherUid|someName:otherName')
self.assertEqual(str(rel_filter), '(|(otherName=Name)(otherUid=123ä))')
rel_filter &= LDAPFilter('(objectClass=person)')
self.assertEqual(
str(rel_filter),
'(&(|(otherName=Name)(otherUid=123ä))(objectClass=person))')
rel_filter = LDAPRelationFilter(node,
'someUid:otherUid|someName:otherName',
False)
self.assertEqual(str(rel_filter), '(&(otherName=Name)(otherUid=123ä))')
rel_filter = LDAPRelationFilter(node,
'someUid:otherUid|someUid:otherName',
False)
self.assertEqual(str(rel_filter), '(&(otherName=123ä)(otherUid=123ä))')
rel_filter = LDAPRelationFilter(
node, 'someUid:otherUid|inexistent:inexistent')
self.assertEqual(str(rel_filter), '(otherUid=123ä)')
def test_IAttributes(self):
# Serialize node implementing ``IAttributes``
node = AttributedNode(name='base')
node.attrs['int'] = 0
node.attrs['float'] = 0.0
node.attrs['str'] = 'str'
node.attrs['unset'] = UNSET
node.attrs['uuid'] = uuid.UUID('fcb30f5a-20c7-43aa-9537-2a25fef0248d')
node.attrs['list'] = [0, 0.0, 'str', UNSET]
json_data = serialize(node)
data = json.loads(json_data)
self.assertEqual(list(data.keys()), ['__node__'])
node_data = data['__node__']
self.assertEqual(
list(sorted(node_data.keys())),
['attrs', 'class', 'name']
)
self.assertEqual(node_data['class'], 'node.base.AttributedNode')
self.assertEqual(node_data['name'], 'base')
attrs_data = node_data['attrs']
self.assertEqual(
list(sorted(attrs_data.keys())),
['float', 'int', 'list', 'str', 'unset', 'uuid']
)
self.assertEqual(attrs_data['int'], 0)
self.assertEqual(attrs_data['float'], 0.0)
self.assertEqual(attrs_data['str'], 'str')
self.assertEqual(attrs_data['list'], [0, 0.0, 'str', '<UNSET>'])
self.assertEqual(attrs_data['unset'], '<UNSET>')
self.assertEqual(
attrs_data['uuid'],
'<UUID>:fcb30f5a-20c7-43aa-9537-2a25fef0248d'
)
# Deserialize node implementing ``IAttributes``
node = deserialize(json_data)
expected = '<AttributedNode object \'base\' at'
self.assertTrue(str(node).startswith(expected))
self.assertEqual(node.attrs['int'], 0)
self.assertEqual(node.attrs['float'], 0.0)
self.assertEqual(node.attrs['str'], 'str')
self.assertEqual(node.attrs['list'], [0, 0.0, 'str', UNSET])
self.assertEqual(node.attrs['unset'], UNSET)
self.assertEqual(
node.attrs['uuid'],
uuid.UUID('fcb30f5a-20c7-43aa-9537-2a25fef0248d')
)
def test_simplified(self):
# Serialize node trees without type information. Such data is not
# deserializable by default deserializer. Supposed to be used for
# domain specific (Browser-) applications dealing with node data
node = BaseNode(name='base')
child = node['child'] = AttributedNode()
child.attrs['foo'] = 'Foo'
child.attrs['ref'] = AbstractNode
# If all nodes are the same type, call ``serialize`` with
# ``simple_mode=True``
json_data = serialize(node, simple_mode=True)
data = json.loads(json_data)
self.assertEqual(sorted(list(data.keys())), ['children', 'name'])
self.assertEqual(data['name'], 'base')
self.assertEqual(len(data['children']), 1)
child_data = data['children'][0]
self.assertEqual(sorted(list(child_data.keys())), ['attrs', 'name'])
self.assertEqual(child_data['name'], 'child')
child_attrs = child_data['attrs']
self.assertEqual(sorted(list(child_attrs.keys())), ['foo', 'ref'])
self.assertEqual(child_attrs['foo'], 'Foo')
self.assertEqual(child_attrs['ref'], 'node.base.AbstractNode')
# If nodes are different types and you do not care about exposing the
# class name, pass ``include_class=True`` to ``serialize``
json_data = serialize(node, simple_mode=True, include_class=True)
data = json.loads(json_data)
self.assertEqual(sorted(list(data.keys())),
['children', 'class', 'name'])
self.assertEqual(data['class'], 'node.base.BaseNode')
self.assertEqual(data['name'], 'base')
self.assertEqual(len(data['children']), 1)
child_data = data['children'][0]
self.assertEqual(sorted(list(child_data.keys())),
['attrs', 'class', 'name'])
self.assertEqual(child_data['class'], 'node.base.AttributedNode')
self.assertEqual(child_data['name'], 'child')
child_attrs = child_data['attrs']
self.assertEqual(sorted(list(child_attrs.keys())), ['foo', 'ref'])
self.assertEqual(child_attrs['foo'], 'Foo')
self.assertEqual(child_attrs['ref'], 'node.base.AbstractNode')
def test_IAttributes(self):
# Serialize node implementing ``IAttributes``
node = AttributedNode(name='base')
node.attrs['int'] = 0
node.attrs['float'] = 0.0
node.attrs['str'] = 'str'
node.attrs['unset'] = UNSET
node.attrs['uuid'] = uuid.UUID('fcb30f5a-20c7-43aa-9537-2a25fef0248d')
node.attrs['list'] = [0, 0.0, 'str', UNSET]
json_data = serialize(node)
data = json.loads(json_data)
self.assertEqual(list(data.keys()), ['__node__'])
node_data = data['__node__']
self.assertEqual(list(sorted(node_data.keys())),
['attrs', 'class', 'name'])
self.assertEqual(node_data['class'], 'node.base.AttributedNode')
self.assertEqual(node_data['name'], 'base')
attrs_data = node_data['attrs']
self.assertEqual(list(sorted(attrs_data.keys())),
['float', 'int', 'list', 'str', 'unset', 'uuid'])
self.assertEqual(attrs_data['int'], 0)
self.assertEqual(attrs_data['float'], 0.0)
self.assertEqual(attrs_data['str'], 'str')
self.assertEqual(attrs_data['list'], [0, 0.0, 'str', '<UNSET>'])
self.assertEqual(attrs_data['unset'], '<UNSET>')
self.assertEqual(attrs_data['uuid'],
'<UUID>:fcb30f5a-20c7-43aa-9537-2a25fef0248d')
# Deserialize node implementing ``IAttributes``
node = deserialize(json_data)
expected = '<AttributedNode object \'base\' at'
self.assertTrue(str(node).startswith(expected))
self.assertEqual(node.attrs['int'], 0)
self.assertEqual(node.attrs['float'], 0.0)
self.assertEqual(node.attrs['str'], 'str')
self.assertEqual(node.attrs['list'], [0, 0.0, 'str', UNSET])
self.assertEqual(node.attrs['unset'], UNSET)
self.assertEqual(node.attrs['uuid'],
uuid.UUID('fcb30f5a-20c7-43aa-9537-2a25fef0248d'))
def test_attr_value(self):
# Test attr_value
widget = AttributedNode()
data = AttributedNode()
widget.attrs['attr'] = 'value'
self.assertEqual(attr_value('attr', widget, data), 'value')
def func_callback(widget, data):
return 'func_callback value'
widget.attrs['attr'] = func_callback
self.assertEqual(attr_value('attr', widget, data),
'func_callback value')
def failing_func_callback(widget, data):
raise Exception('failing_func_callback')
widget.attrs['attr'] = failing_func_callback
err = self.expect_error(Exception, attr_value, 'attr', widget, data)
self.assertEqual(str(err), 'failing_func_callback')
def bc_func_callback():
return 'bc_func_callback value'
widget.attrs['attr'] = bc_func_callback
self.assertEqual(attr_value('attr', widget, data),
'bc_func_callback value')
def failing_bc_func_callback():
raise Exception('failing_bc_func_callback')
widget.attrs['attr'] = failing_bc_func_callback
err = self.expect_error(Exception, attr_value, 'attr', widget, data)
self.assertEqual(str(err), 'failing_bc_func_callback')
class FormContext(object):
def instance_callback(self, widget, data):
return 'instance_callback'
def failing_instance_callback(self, widget, data):
raise Exception('failing_instance_callback')
def instance_bc_callback(self):
return 'instance_bc_callback'
def failing_instance_bc_callback(self, widget, data):
raise Exception('failing_instance_bc_callback')
context = FormContext()
widget.attrs['attr'] = context.instance_callback
self.assertEqual(attr_value('attr', widget, data), 'instance_callback')
widget.attrs['attr'] = context.failing_instance_callback
err = self.expect_error(Exception, attr_value, 'attr', widget, data)
self.assertEqual(str(err), 'failing_instance_callback')
widget.attrs['attr'] = context.instance_bc_callback
self.assertEqual(attr_value('attr', widget, data),
'instance_bc_callback')
widget.attrs['attr'] = context.failing_instance_bc_callback
err = self.expect_error(Exception, attr_value, 'attr', widget, data)
self.assertEqual(str(err), 'failing_instance_bc_callback')
def test_data_attrs_helper(self):
data = AttributedNode()
widget = AttributedNode()
widget.attrs['testattr1'] = 'value'
widget.attrs['testattr2'] = True
widget.attrs['testattr3'] = False
widget.attrs['testattr4'] = None
widget.attrs['testattr5'] = ['item1', 'item2', 'item3']
widget.attrs['testattr6'] = {
'key1': 'item1',
'key2': 'item2',
'key3': 'item3'
}
widget.attrs['testattr7'] = 1234
widget.attrs['testattr8'] = 1234.5678
widget.attrs['testattr9'] = UNSET
widget.attrs['camelAttrName'] = 'camelValue'
data_attrs_keys = [
'testattr1', 'testattr2', 'testattr3', 'testattr4', 'testattr5',
'testattr6', 'testattr7', 'testattr8', 'camelAttrName'
]
data_attrs = data_attrs_helper(widget, data, data_attrs_keys)
self.assertEqual(data_attrs['data-testattr1'], 'value')
self.assertEqual(data_attrs['data-testattr2'], 'true')
self.assertEqual(data_attrs['data-testattr3'], 'false')
self.assertFalse('data-testattr4' in data_attrs)
self.assertEqual(
data_attrs['data-testattr5'],
'["item1", "item2", "item3"]'
)
self.assertTrue(data_attrs['data-testattr6'].find('"key1": "item1"'))
self.assertTrue(data_attrs['data-testattr6'].find('"key2": "item2"'))
self.assertTrue(data_attrs['data-testattr6'].find('"key3": "item3"'))
self.assertTrue(data_attrs['data-testattr6'].startswith('{'))
self.assertTrue(data_attrs['data-testattr6'].endswith('}'))
self.assertEqual(data_attrs['data-testattr7'], '1234')
self.assertEqual(data_attrs['data-testattr8'], '1234.5678')
self.assertFalse('data-testattr9' in data_attrs)
self.assertEqual(data_attrs['data-camel-attr-name'], 'camelValue')
# Test with Tag renderer
tag = Tag(lambda msg: msg)
self.check_output("""
<dummy
data-camel-attr-name='camelValue'
data-testattr1='value'
data-testattr2='true'
data-testattr3='false'
data-testattr5='["item1", "item2", "item3"]'
data-testattr6='{"..."}'
data-testattr7='1234'
data-testattr8='1234.5678'
name="foo" />
""", tag('dummy', name='foo', **data_attrs))
def test_attr_value(self):
# Test attr_value
widget = AttributedNode()
data = AttributedNode()
widget.attrs['attr'] = 'value'
self.assertEqual(attr_value('attr', widget, data), 'value')
def func_callback(widget, data):
return 'func_callback value'
widget.attrs['attr'] = func_callback
self.assertEqual(
attr_value('attr', widget, data),
'func_callback value'
)
def failing_func_callback(widget, data):
raise Exception('failing_func_callback')
widget.attrs['attr'] = failing_func_callback
err = self.expect_error(
Exception,
attr_value,
'attr', widget, data
)
self.assertEqual(str(err), 'failing_func_callback')
def bc_func_callback():
return 'bc_func_callback value'
widget.attrs['attr'] = bc_func_callback
self.assertEqual(
attr_value('attr', widget, data),
'bc_func_callback value'
)
def failing_bc_func_callback():
raise Exception('failing_bc_func_callback')
widget.attrs['attr'] = failing_bc_func_callback
err = self.expect_error(
Exception,
attr_value,
'attr', widget, data
)
self.assertEqual(str(err), 'failing_bc_func_callback')
class FormContext(object):
def instance_callback(self, widget, data):
return 'instance_callback'
def failing_instance_callback(self, widget, data):
raise Exception('failing_instance_callback')
def instance_bc_callback(self):
return 'instance_bc_callback'
def failing_instance_bc_callback(self, widget, data):
raise Exception('failing_instance_bc_callback')
context = FormContext()
widget.attrs['attr'] = context.instance_callback
self.assertEqual(
attr_value('attr', widget, data),
'instance_callback'
)
widget.attrs['attr'] = context.failing_instance_callback
err = self.expect_error(
Exception,
attr_value,
'attr', widget, data
)
self.assertEqual(str(err), 'failing_instance_callback')
widget.attrs['attr'] = context.instance_bc_callback
self.assertEqual(
attr_value('attr', widget, data),
'instance_bc_callback'
)
widget.attrs['attr'] = context.failing_instance_bc_callback
err = self.expect_error(
Exception,
attr_value,
'attr', widget, data
)
self.assertEqual(str(err), 'failing_instance_bc_callback')
def create(self, pid, **kw):
vessel = AttributedNode()
for k, v in kw.items():
vessel.attrs[k] = v
self[pid] = vessel
return self[pid]
def create(self, pid, **kw):
vessel = AttributedNode()
for k, v in kw.items():
vessel.attrs[k] = v
self[pid] = vessel
return self[pid]
def test_data_attrs_helper(self):
data = AttributedNode()
widget = AttributedNode()
widget.attrs['testattr1'] = 'value'
widget.attrs['testattr2'] = True
widget.attrs['testattr3'] = False
widget.attrs['testattr4'] = None
widget.attrs['testattr5'] = ['item1', 'item2', 'item3']
widget.attrs['testattr6'] = {
'key1': 'item1',
'key2': 'item2',
'key3': 'item3'
}
widget.attrs['testattr7'] = 1234
widget.attrs['testattr8'] = 1234.5678
widget.attrs['testattr9'] = UNSET
widget.attrs['camelAttrName'] = 'camelValue'
data_attrs_keys = [
'testattr1', 'testattr2', 'testattr3', 'testattr4', 'testattr5',
'testattr6', 'testattr7', 'testattr8', 'camelAttrName'
]
data_attrs = data_attrs_helper(widget, data, data_attrs_keys)
self.assertEqual(data_attrs['data-testattr1'], 'value')
self.assertEqual(data_attrs['data-testattr2'], 'true')
self.assertEqual(data_attrs['data-testattr3'], 'false')
self.assertFalse('data-testattr4' in data_attrs)
self.assertEqual(data_attrs['data-testattr5'],
'["item1", "item2", "item3"]')
self.assertTrue(data_attrs['data-testattr6'].find('"key1": "item1"'))
self.assertTrue(data_attrs['data-testattr6'].find('"key2": "item2"'))
self.assertTrue(data_attrs['data-testattr6'].find('"key3": "item3"'))
self.assertTrue(data_attrs['data-testattr6'].startswith('{'))
self.assertTrue(data_attrs['data-testattr6'].endswith('}'))
self.assertEqual(data_attrs['data-testattr7'], '1234')
self.assertEqual(data_attrs['data-testattr8'], '1234.5678')
self.assertFalse('data-testattr9' in data_attrs)
self.assertEqual(data_attrs['data-camel-attr-name'], 'camelValue')
# Test with Tag renderer
tag = Tag(lambda msg: msg)
self.check_output(
"""
<dummy
data-camel-attr-name='camelValue'
data-testattr1='value'
data-testattr2='true'
data-testattr3='false'
data-testattr5='["item1", "item2", "item3"]'
data-testattr6='{"..."}'
data-testattr7='1234'
data-testattr8='1234.5678'
name="foo" />
""", tag('dummy', name='foo', **data_attrs))
