def create_from_resource(cls, resource):
# Create the wrapping element.
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(type(resource))
xml_ns = mp.configuration.get_option(XML_NAMESPACE_OPTION)
options = {XML_NAMESPACE_OPTION:xml_ns}
rc_data_el = mp.create_data_element_from_resource(resource)
if provides_member_resource(resource):
link_el = cls.create(resource_to_url(resource),
RESOURCE_KINDS.MEMBER,
id=str(resource.id),
relation=resource.relation,
title=resource.title,
**options)
rc_data_el.set('id', str(resource.id))
rc_data_el.append(link_el)
else: # collection resource.
# Collection links only get an actual link element if they
# contain any members.
link_el = cls.create(resource_to_url(resource),
RESOURCE_KINDS.COLLECTION,
relation=resource.relation,
title=resource.title,
**options)
rc_data_el.append(link_el)
return rc_data_el
def test_map_to_data_element_with_collection(self, resource_repo):
entity = create_entity()
coll = resource_repo.get_collection(IMyEntity)
mb = coll.create_member(entity)
assert len(entity.children) == 1
assert len(mb.children) == 1
mb_child = next(iter(mb.children))
assert len(mb_child.children) == 1
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(
attribute_options={
('children', ): {
IGNORE_OPTION: False,
WRITE_AS_LINK_OPTION: False
},
('children', 'children'): {
IGNORE_OPTION: False,
WRITE_AS_LINK_OPTION: False
}
})
de = mp1.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
assert len(prx.children) == 1
assert len(prx.children[0].children) == 1
def _test(cnt_type, parent_repr_name, children_repr_name):
entity = create_entity()
mb = MyEntityMember.create_from_entity(entity)
mp_reg = get_mapping_registry(cnt_type)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
de = mp.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
self.assert_true(prx.get_data_element() is de)
self.assert_equal(prx.id, 0)
self.assert_equal(prx.text, 'TEXT')
self.assert_equal(prx.number, 1)
# The parent and children attributes are links.
self.assert_true(
isinstance(getattr(prx, parent_repr_name), LinkedDataElement))
children_el = getattr(prx, children_repr_name)
if cnt_type is XmlMime:
self.assert_is_none(children_el)
else:
self.assert_true(isinstance(children_el, LinkedDataElement))
# Nonexisting attribute raises error.
self.assert_raises(AttributeError, getattr, prx, 'foo')
self.assert_raises(AttributeError, setattr, prx, 'foo', 'murks')
# Set terminal attribute.
prx.id = 1
self.assert_equal(prx.id, 1)
# Set nested attribute.
setattr(prx, parent_repr_name, None)
self.assert_is_none(getattr(prx, parent_repr_name))
self.assert_raises(ValueError, setattr, prx, parent_repr_name, 1)
def test_mapping_polymorhpic(self):
# pylint: disable=W0232
class IMyDerivedEntity(IMyEntity):
pass
class MyDerivedEntity(MyEntity):
pass
class MyDerivedEntityMember(MyEntityMember):
pass
class MyDerivedEntityCollection(get_collection_class(IMyEntity)):
pass
# pylint: enable=W0232
self.config.add_resource(IMyDerivedEntity, MyDerivedEntityMember,
MyDerivedEntity, MyDerivedEntityCollection,
expose=False)
self.config.add_resource_representer(
IMyDerivedEntity,
XmlMime,
attribute_options=
{('parent',):dict(ignore=True)})
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
for rc in (MyDerivedEntityMember, MyDerivedEntityCollection):
attr = None
for attr in mp.attribute_iterator(rc):
if attr.name == 'parent':
break
self.assert_is_not_none(attr)
self.assert_equal(attr.ignore_on_write, True)
self.assert_equal(attr.ignore_on_read, True)
def _test(cnt_type, parent_repr_name, children_repr_name):
entity = create_entity()
mb = MyEntityMember.create_from_entity(entity)
mp_reg = get_mapping_registry(cnt_type)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
de = mp.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
self.assert_true(prx.get_data_element() is de)
self.assert_equal(prx.id, 0)
self.assert_equal(prx.text, 'TEXT')
self.assert_equal(prx.number, 1)
# The parent and children attributes are links.
self.assert_true(isinstance(getattr(prx, parent_repr_name),
LinkedDataElement))
children_el = getattr(prx, children_repr_name)
if cnt_type is XmlMime:
self.assert_is_none(children_el)
else:
self.assert_true(isinstance(children_el, LinkedDataElement))
# Nonexisting attribute raises error.
self.assert_raises(AttributeError, getattr, prx, 'foo')
self.assert_raises(AttributeError, setattr, prx, 'foo', 'murks')
# Set terminal attribute.
prx.id = 1
self.assert_equal(prx.id, 1)
# Set nested attribute.
setattr(prx, parent_repr_name, None)
self.assert_is_none(getattr(prx, parent_repr_name))
self.assert_raises(ValueError, setattr, prx, parent_repr_name,
1)
def create_from_resource(cls, resource):
# Create the wrapping element.
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(type(resource))
xml_ns = mp.configuration.get_option(XML_NAMESPACE_OPTION)
options = {XML_NAMESPACE_OPTION:xml_ns}
rc_data_el = mp.create_data_element_from_resource(resource)
if provides_member_resource(resource):
link_el = cls.create(resource_to_url(resource),
RESOURCE_KINDS.MEMBER,
id=str(resource.id),
relation=resource.relation,
title=resource.title,
**options)
rc_data_el.set('id', str(resource.id))
rc_data_el.append(link_el)
else: # collection resource.
# Collection links only get an actual link element if they
# contain any members.
link_el = cls.create(resource_to_url(resource),
RESOURCE_KINDS.COLLECTION,
relation=resource.relation,
title=resource.title,
**options)
rc_data_el.append(link_el)
return rc_data_el
def _test(mb, cnt_type, parent_repr_name, children_repr_name):
mp_reg = get_mapping_registry(cnt_type)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
de = mp.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
assert prx.get_data_element() is de
assert prx.id == 0
assert prx.text == 'TEXT'
assert prx.number == 1
if cnt_type is XmlMime:
# The parent attribute is a link.
assert isinstance(getattr(prx, parent_repr_name),
LinkedDataElement)
with pytest.raises(AttributeError):
dummy = getattr(prx, children_repr_name)
else:
assert isinstance(getattr(prx, parent_repr_name),
DataElementAttributeProxy)
children_el = getattr(prx, children_repr_name)
assert isinstance(children_el, LinkedDataElement)
# Nonexisting attribute raises error.
with pytest.raises(AttributeError):
dummy = getattr(prx, 'foo')
with pytest.raises(AttributeError):
setattr(prx, 'foo', 'murks')
# Set terminal attribute.
prx.id = 1
assert prx.id == 1
# Set nested attribute.
setattr(prx, parent_repr_name, None)
assert getattr(prx, parent_repr_name) is None
with pytest.raises(ValueError):
setattr(prx, parent_repr_name, 1)
def _test(mb, cnt_type, parent_repr_name, children_repr_name):
mp_reg = get_mapping_registry(cnt_type)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
de = mp.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
assert prx.get_data_element() is de
assert prx.id == 0
assert prx.text == 'TEXT'
assert prx.number == 1
if cnt_type is XmlMime:
# The parent attribute is a link.
assert isinstance(getattr(prx, parent_repr_name),
LinkedDataElement)
with pytest.raises(AttributeError):
dummy = getattr(prx, children_repr_name)
else:
assert isinstance(getattr(prx, parent_repr_name),
DataElementAttributeProxy)
children_el = getattr(prx, children_repr_name)
assert isinstance(children_el, LinkedDataElement)
# Nonexisting attribute raises error.
with pytest.raises(AttributeError):
dummy = getattr(prx, 'foo')
with pytest.raises(AttributeError):
setattr(prx, 'foo', 'murks')
# Set terminal attribute.
prx.id = 1
assert prx.id == 1
# Set nested attribute.
setattr(prx, parent_repr_name, None)
assert getattr(prx, parent_repr_name) is None
with pytest.raises(ValueError):
setattr(prx, parent_repr_name, 1)
def test_mapping_duplicate_prefix(self):
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
ns = 'foo'
mp.configuration.set_option(XML_NAMESPACE_OPTION, ns)
with self.assert_raises(ValueError) as cm:
mp.mapping_registry.set_mapping(mp)
exc_msg = 'is already registered for namespace'
self.assert_not_equal(cm.exception.message.find(exc_msg), -1)
def test_clone_with_options(self):
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(
attribute_options={('parent', 'text'):{IGNORE_OPTION:True}})
key = ('parent',)
parent_attrs = mp1.get_attribute_map(key=key)
self.assert_true(
parent_attrs['text'].options.get(IGNORE_OPTION) is True)
def test_mapping_duplicate_prefix(self):
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
ns = 'foo'
mp.configuration.set_option(XML_NAMESPACE_OPTION, ns)
with self.assert_raises(ValueError) as cm:
mp.mapping_registry.set_mapping(mp)
exc_msg = 'is already registered for namespace'
self.assert_not_equal(cm.exception.message.find(exc_msg), -1)
def test_mapping_duplicate_tag(self):
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
mb_mp = mp_reg.find_or_create_mapping(MyEntityMember)
mb_tag = mb_mp.configuration.get_option(XML_TAG_OPTION)
mp.configuration.set_option(XML_TAG_OPTION, mb_tag)
mp.mapping_registry.set_mapping(mp)
with self.assert_raises(ValueError) as cm:
getattr(mp.mapping_registry, 'parsing_lookup')
self.assert_true(str(cm.exception).startswith('Duplicate tag'))
def create_from_resource_class(cls, resource_class):
"""
Creates a new representer for the given resource class.
The representer obtains a reference to the (freshly created or looked
up) mapping for the resource class.
"""
mp_reg = get_mapping_registry(cls.content_type)
mp = mp_reg.find_or_create_mapping(resource_class)
return cls(resource_class, mp)
def test_defaults(self):
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
attrs = mp.get_attribute_map()
self.assert_true(attrs['text'].options.get(IGNORE_OPTION) is None)
self.assert_true(attrs['parent'].options.get(IGNORE_OPTION) is None)
key = ('parent',)
parent_attrs = mp.get_attribute_map(key=key)
self.assert_true(
parent_attrs['text'].options.get(IGNORE_OPTION) is None)
def create(cls, schema_location=None):
if not schema_location is None:
schema = cls.__get_xml_schema(schema_location)
parser = objectify.makeparser(schema=schema)
else:
parser = objectify.makeparser()
# Get the class lookup from the mapping registry.
mp_reg = get_mapping_registry(XmlMime)
parser.set_element_class_lookup(mp_reg.parsing_lookup)
return parser
def namespace_map(self):
atom_ns_map = \
getattr(XmlMappingRegistry, 'namespace_map').__get__(self)
xml_mp_reg = get_mapping_registry(XmlMime)
xml_ns_map = xml_mp_reg.namespace_map
atom_ns_map.update(xml_ns_map)
# Make ATOM namespace the default.
del atom_ns_map[XML_PREFIX_ATOM]
atom_ns_map[None] = XML_NS_ATOM
return atom_ns_map
def create_from_resource_class(cls, resource_class):
"""
Creates a new representer for the given resource class.
The representer obtains a reference to the (freshly created or looked
up) mapping for the resource class.
"""
mp_reg = get_mapping_registry(cls.content_type)
mp = mp_reg.find_or_create_mapping(resource_class)
return cls(resource_class, mp)
def create(cls, schema_location=None):
if not schema_location is None:
schema = cls.__get_xml_schema(schema_location)
parser = objectify.makeparser(schema=schema)
else:
parser = objectify.makeparser()
# Get the class lookup from the mapping registry.
mp_reg = get_mapping_registry(XmlMime)
parser.set_element_class_lookup(mp_reg.parsing_lookup)
return parser
def test_mapping_linked_xml_data_element_with_string_id(self):
mp_reg = get_mapping_registry(XmlMime)
mb_mp = mp_reg.find_or_create_mapping(MyEntityMember)
coll = create_collection()
mb = next(iter(coll))
mb_id = 'unique'
mb.id = mb_id
data_el = mb_mp.create_linked_data_element_from_resource(mb)
link_el = next(data_el.iterchildren())
self.assert_equal(link_el.get_id(), mb.id)
def namespace_map(self):
atom_ns_map = \
getattr(XmlMappingRegistry, 'namespace_map').__get__(self)
xml_mp_reg = get_mapping_registry(XmlMime)
xml_ns_map = xml_mp_reg.namespace_map
atom_ns_map.update(xml_ns_map)
# Make ATOM namespace the default.
del atom_ns_map[XML_PREFIX_ATOM]
atom_ns_map[None] = XML_NS_ATOM
return atom_ns_map
def test_mapping_duplicate_tag(self):
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
mb_mp = mp_reg.find_or_create_mapping(MyEntityMember)
mb_tag = mb_mp.configuration.get_option(XML_TAG_OPTION)
mp.configuration.set_option(XML_TAG_OPTION, mb_tag)
mp.mapping_registry.set_mapping(mp)
with self.assert_raises(ValueError) as cm:
getattr(mp.mapping_registry, 'parsing_lookup')
exc_msg = 'Duplicate tag "%s" ' % mb_tag
self.assert_not_equal(cm.exception.message.find(exc_msg), -1)
def test_mapping_duplicate_tag(self):
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
mb_mp = mp_reg.find_or_create_mapping(MyEntityMember)
mb_tag = mb_mp.configuration.get_option(XML_TAG_OPTION)
mp.configuration.set_option(XML_TAG_OPTION, mb_tag)
mp.mapping_registry.set_mapping(mp)
with self.assert_raises(ValueError) as cm:
getattr(mp.mapping_registry, 'parsing_lookup')
exc_msg = 'Duplicate tag "%s" ' % mb_tag
self.assert_not_equal(cm.exception.message.find(exc_msg), -1)
def test_clone_with_options(self):
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(attribute_options={
('parent', 'text'): {
IGNORE_ON_READ_OPTION: True
}
})
key = ('parent', )
parent_attrs = mp1.get_attribute_map(key=key)
self.assert_true(
parent_attrs['text'].options.get(IGNORE_ON_READ_OPTION) is True)
def test_mapping_reset_lookup(self):
mp_reg = get_mapping_registry(XmlMime)
old_lookup = mp_reg.parsing_lookup
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
new_tag = 'my-new-entities'
mp.configuration.set_option(XML_TAG_OPTION, new_tag)
mp_reg.set_mapping(mp)
new_lookup = mp_reg.parsing_lookup
self.assert_false(old_lookup is new_lookup)
ns = mp.configuration.get_option(XML_NAMESPACE_OPTION)
cls_map = new_lookup.get_namespace(ns)
self.assert_equal(cls_map[new_tag], mp.data_element_class)
def test_mapping_reset_lookup(self):
mp_reg = get_mapping_registry(XmlMime)
old_lookup = mp_reg.parsing_lookup
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
new_tag = 'my-new-entities'
mp.configuration.set_option(XML_TAG_OPTION, new_tag)
mp_reg.set_mapping(mp)
new_lookup = mp_reg.parsing_lookup
self.assert_false(old_lookup is new_lookup)
ns = mp.configuration.get_option(XML_NAMESPACE_OPTION)
cls_map = new_lookup.get_namespace(ns)
self.assert_equal(cls_map[new_tag], mp.data_element_class)
def map_to_data_element(self, resource):
# We use the XML mapping for the content serialization.
xml_mp_reg = get_mapping_registry(XmlMime)
xml_mp = xml_mp_reg.find_or_create_mapping(type(resource))
ns_map = self.mapping_registry.namespace_map
atom_mp = self.mapping_registry.find_or_create_mapping(type(resource))
data_el = \
atom_mp.data_element_class.create_from_resource(resource,
ns_map=ns_map)
if provides_member_resource(resource):
self.__map_member_to_data_element(data_el, resource, xml_mp)
else:
self.__map_collection_to_data_element(data_el, resource, xml_mp)
return data_el
def map_to_data_element(self, resource):
# We use the XML mapping for the content serialization.
xml_mp_reg = get_mapping_registry(XmlMime)
xml_mp = xml_mp_reg.find_or_create_mapping(type(resource))
ns_map = self.mapping_registry.namespace_map
atom_mp = self.mapping_registry.find_or_create_mapping(type(resource))
data_el = \
atom_mp.data_element_class.create_from_resource(resource,
ns_map=ns_map)
if provides_member_resource(resource):
self.__map_member_to_data_element(data_el, resource, xml_mp)
else:
self.__map_collection_to_data_element(data_el, resource, xml_mp)
return data_el
def test_json_data_tree_traverser(self):
mp_reg = get_mapping_registry(JsonMime)
default_mp = mp_reg.find_or_create_mapping(MyEntityMember)
attr_opts = {('parent',):{WRITE_AS_LINK_OPTION:False}}
mp = default_mp.clone(attribute_options=attr_opts)
vst = DataElementBuilderRepresentationDataVisitor(mp)
for json_data, exc_msg in ((object, 'Need dict (member),'),
({'parent':
{'__jsonclass__':'http://foo.org'}},
'Expected data for'),):
trv = JsonDataTreeTraverser(json_data, mp)
with self.assert_raises(ValueError) as cm:
trv.run(vst)
self.assert_true(cm.exception.message.startswith(exc_msg))
def test_map_to_data_element_with_collection(self):
entity = create_entity()
mb = MyEntityMember.create_from_entity(entity)
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(
attribute_options={('children',):{IGNORE_ON_WRITE_OPTION:False,
WRITE_AS_LINK_OPTION:False},
('children', 'children'):
{IGNORE_ON_WRITE_OPTION:False,
WRITE_AS_LINK_OPTION:False}
})
de = mp1.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
self.assert_equal(len(prx.children), 1)
self.assert_equal(len(prx.children[0].children), 1)
def test_map_to_data_element_with_member(self):
entity = create_entity()
mb = MyEntityMember.create_from_entity(entity)
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(
attribute_options={('parent',):{WRITE_AS_LINK_OPTION:False},
})
de = mp1.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
self.assert_is_not_none(prx.parent)
#
entity.parent = None
de1 = mp1.map_to_data_element(mb)
prx1 = DataElementAttributeProxy(de1)
self.assert_is_none(prx1.parent)
def test_map_to_data_element_with_member(self):
entity = create_entity()
mb = MyEntityMember.create_from_entity(entity)
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(attribute_options={
('parent', ): {
WRITE_AS_LINK_OPTION: False
},
})
de = mp1.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
self.assert_is_not_none(prx.parent)
#
entity.parent = None
de1 = mp1.map_to_data_element(mb)
prx1 = DataElementAttributeProxy(de1)
self.assert_is_none(prx1.parent)
def test_defaults(self):
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
attrs = mp.get_attribute_map()
self.assert_true(
attrs['text'].options.get(IGNORE_ON_READ_OPTION) is None)
self.assert_true(
attrs['text'].options.get(IGNORE_ON_WRITE_OPTION) is None)
self.assert_true(
attrs['parent'].options.get(IGNORE_ON_READ_OPTION) is None)
self.assert_true(
attrs['parent'].options.get(IGNORE_ON_WRITE_OPTION) is None)
key = ('parent', )
parent_attrs = mp.get_attribute_map(key=key)
self.assert_true(
parent_attrs['text'].options.get(IGNORE_ON_READ_OPTION) is None)
self.assert_true(
parent_attrs['text'].options.get(IGNORE_ON_WRITE_OPTION) is None)
def _create(cls, ns_map):
if ns_map is None:
mp_reg = get_mapping_registry(XmlMime)
ns_map = mp_reg.namespace_map
cls_xml_tag = cls.mapping.configuration.get_option(XML_TAG_OPTION)
if cls_xml_tag is None:
raise ValueError('No XML tag registered for mapped class '
'%s.' % cls.mapping.mapped_class)
cls_xml_ns = \
cls.mapping.configuration.get_option(XML_NAMESPACE_OPTION)
if not cls_xml_ns is None:
tag = "{%s}%s" % (cls_xml_ns, cls_xml_tag)
# FIXME: is this really necessary?
ns_map[None] = cls_xml_ns
else:
tag = cls_xml_tag
el_fac = XmlParserFactory.create().makeelement
return el_fac(tag, nsmap=ns_map)
def test_json_data_tree_traverser(self):
mp_reg = get_mapping_registry(JsonMime)
default_mp = mp_reg.find_or_create_mapping(MyEntityMember)
attr_opts = {('parent', ): {WRITE_AS_LINK_OPTION: False}}
mp = default_mp.clone(attribute_options=attr_opts)
vst = DataElementBuilderRepresentationDataVisitor(mp)
for json_data, exc_msg in (
(object, 'Need dict (member),'),
({
'parent': {
'__jsonclass__': 'http://foo.org'
}
}, 'Expected data for'),
):
trv = JsonDataTreeTraverser(json_data, mp)
with self.assert_raises(ValueError) as cm:
trv.run(vst)
self.assert_true(cm.exception.message.startswith(exc_msg))
def test_map_to_data_element_with_member(self, resource_repo):
entity = create_entity()
coll = resource_repo.get_collection(IMyEntity)
mb = coll.create_member(entity)
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(
attribute_options={('parent',):{WRITE_AS_LINK_OPTION:False},
})
de = mp1.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
assert not prx.parent is None
#
entity.parent = None
de1 = mp1.map_to_data_element(mb)
prx1 = DataElementAttributeProxy(de1)
with pytest.raises(AttributeError):
dummy = getattr(prx1, 'parent')
def _create(cls, ns_map):
if ns_map is None:
mp_reg = get_mapping_registry(XmlMime)
ns_map = mp_reg.namespace_map
cls_xml_tag = cls.mapping.configuration.get_option(XML_TAG_OPTION)
if cls_xml_tag is None:
raise ValueError('No XML tag registered for mapped class '
'%s.' % cls.mapping.mapped_class)
cls_xml_ns = \
cls.mapping.configuration.get_option(XML_NAMESPACE_OPTION)
if not cls_xml_ns is None:
tag = "{%s}%s" % (cls_xml_ns, cls_xml_tag)
# FIXME: is this really necessary?
ns_map[None] = cls_xml_ns
else:
tag = cls_xml_tag
el_fac = XmlParserFactory.create().makeelement
return el_fac(tag, nsmap=ns_map)
def test_map_to_data_element_with_collection(self):
entity = create_entity()
mb = MyEntityMember.create_from_entity(entity)
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(
attribute_options={
('children', ): {
IGNORE_ON_WRITE_OPTION: False,
WRITE_AS_LINK_OPTION: False
},
('children', 'children'): {
IGNORE_ON_WRITE_OPTION: False,
WRITE_AS_LINK_OPTION: False
}
})
de = mp1.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
self.assert_equal(len(prx.children), 1)
self.assert_equal(len(prx.children[0].children), 1)
def test_map_to_data_element_with_member(self, resource_repo):
entity = create_entity()
coll = resource_repo.get_collection(IMyEntity)
mb = coll.create_member(entity)
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(attribute_options={
('parent', ): {
WRITE_AS_LINK_OPTION: False
},
})
de = mp1.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
assert not prx.parent is None
#
entity.parent = None
de1 = mp1.map_to_data_element(mb)
prx1 = DataElementAttributeProxy(de1)
with pytest.raises(AttributeError):
dummy = getattr(prx1, 'parent')
def test_map_to_data_element_with_collection(self, resource_repo):
entity = create_entity()
coll = resource_repo.get_collection(IMyEntity)
mb = coll.create_member(entity)
assert len(entity.children) == 1
assert len(mb.children) == 1
mb_child = next(iter(mb.children))
assert len(mb_child.children) == 1
mp_reg = get_mapping_registry(CsvMime)
mp = mp_reg.find_or_create_mapping(MyEntityMember)
mp1 = mp.clone(
attribute_options={('children',):{IGNORE_OPTION:False,
WRITE_AS_LINK_OPTION:False},
('children', 'children'):
{IGNORE_OPTION:False,
WRITE_AS_LINK_OPTION:False}
})
de = mp1.map_to_data_element(mb)
prx = DataElementAttributeProxy(de)
assert len(prx.children) == 1
assert len(prx.children[0].children) == 1
def test_mapping_polymorhpic(self):
# pylint: disable=W0232
class IMyDerivedEntity(IMyEntity):
pass
class MyDerivedEntity(MyEntity):
pass
class MyDerivedEntityMember(MyEntityMember):
pass
class MyDerivedEntityCollection(get_collection_class(IMyEntity)):
pass
# pylint: enable=W0232
self.config.add_resource(IMyDerivedEntity,
MyDerivedEntityMember,
MyDerivedEntity,
MyDerivedEntityCollection,
expose=False)
self.config.add_resource_representer(IMyDerivedEntity,
XmlMime,
attribute_options={
('parent', ):
dict(ignore=True)
})
mp_reg = get_mapping_registry(XmlMime)
mp = mp_reg.find_or_create_mapping(get_collection_class(IMyEntity))
for rc in (MyDerivedEntityMember, MyDerivedEntityCollection):
attr = None
for attr in mp.attribute_iterator(rc):
if attr.name == 'parent':
break
self.assert_is_not_none(attr)
self.assert_equal(attr.ignore_on_write, True)
self.assert_equal(attr.ignore_on_read, True)
def create_from_resource(cls, rc):
mp_reg = get_mapping_registry(cls.content_type)
rc_cls = type(rc)
mp = mp_reg.find_or_create_mapping(rc_cls)
return cls(rc_cls, mp)
def __get_ns_map(self):
ns_map = get_mapping_registry(AtomMime).namespace_map
ns_map[XML_PREFIX_ATOM] = XML_NS_ATOM
if None in ns_map:
del ns_map[None]
return ns_map
def create_from_resource(cls, rc):
mp_reg = get_mapping_registry(cls.content_type)
rc_cls = type(rc)
mp = mp_reg.find_or_create_mapping(rc_cls)
return cls(rc_cls, mp)
def __get_ns_map(self):
ns_map = get_mapping_registry(AtomMime).namespace_map
ns_map[XML_PREFIX_ATOM] = XML_NS_ATOM
if None in ns_map:
del ns_map[None]
return ns_map