def test_add_default_attribute(self):
xs_string = AttrTypeFactory.native(DataType.STRING)
extension = ExtensionFactory.create(xs_string,
Restrictions(required=True))
item = ClassFactory.elements(1, extensions=[extension])
ClassExtensionHandler.add_default_attribute(item, extension)
expected = AttrFactory.create(name="@value",
default=None,
types=[xs_string],
tag=Tag.EXTENSION)
self.assertEqual(2, len(item.attrs))
self.assertEqual(0, len(item.extensions))
self.assertEqual(expected, item.attrs[0])
xs_int = AttrTypeFactory.native(DataType.INT)
extension = ExtensionFactory.create(xs_int, Restrictions(tokens=True))
item.extensions.append(extension)
ClassExtensionHandler.add_default_attribute(item, extension)
expected.types.append(xs_int)
expected_restrictions = Restrictions(tokens=True,
required=True,
min_occurs=1,
max_occurs=1)
self.assertEqual(2, len(item.attrs))
self.assertEqual(0, len(item.extensions))
self.assertEqual(expected, item.attrs[0])
self.assertEqual(expected_restrictions, item.attrs[0].restrictions)
def test_rename_class_dependencies(self):
attr_type = AttrTypeFactory.create("{foo}bar")
target = ClassFactory.create(
extensions=[
ExtensionFactory.create(),
ExtensionFactory.create(attr_type.clone()),
],
attrs=[
AttrFactory.create(),
AttrFactory.create(
types=[AttrTypeFactory.create(),
attr_type.clone()]),
],
inner=[
ClassFactory.create(
extensions=[ExtensionFactory.create(attr_type.clone())],
attrs=[
AttrFactory.create(),
AttrFactory.create(types=[
AttrTypeFactory.create(),
attr_type.clone()
]),
],
)
],
)
self.sanitizer.rename_class_dependencies(target, "{foo}bar", "thug")
dependencies = set(target.dependencies())
self.assertNotIn("{foo}bar", dependencies)
self.assertIn("thug", dependencies)
def test_copy_attributes(self, mock_clone_attribute, mock_copy_inner_classes):
mock_clone_attribute.side_effect = lambda x, y: x.clone()
target = ClassFactory.create(
attrs=[AttrFactory.create(name="a"), AttrFactory.create(name="b")]
)
source = ClassFactory.create(
attrs=[
AttrFactory.create(name="c", index=sys.maxsize),
AttrFactory.create(name="a"),
AttrFactory.create(name="b"),
AttrFactory.create(name="d"),
]
)
extension = ExtensionFactory.create(AttrTypeFactory.create(qname="foo"))
target.extensions.append(extension)
ClassUtils.copy_attributes(source, target, extension)
self.assertEqual(["a", "b", "d", "c"], [attr.name for attr in target.attrs])
mock_copy_inner_classes.assert_has_calls(
[
mock.call(source, target, source.attrs[0]),
mock.call(source, target, source.attrs[3]),
]
)
mock_clone_attribute.assert_has_calls(
[
mock.call(source.attrs[0], extension.restrictions),
mock.call(source.attrs[3], extension.restrictions),
]
)
def test_process_native_extension_with_enumeration_target(
self, mock_replace_attributes_type):
extension = ExtensionFactory.create()
target = ClassFactory.enumeration(1)
self.processor.process_native_extension(target, extension)
mock_replace_attributes_type.assert_called_once_with(target, extension)
def test_process_simple_extension_when_source_is_enumeration_and_target_is_not(
self, mock_add_default_attribute):
source = ClassFactory.enumeration(2)
target = ClassFactory.elements(1)
extension = ExtensionFactory.create()
self.processor.process_simple_extension(source, target, extension)
mock_add_default_attribute.assert_called_once_with(target, extension)
def test_process_extension_with_dependency_type(
self, mock_process_dependency_extension):
extension = ExtensionFactory.create(AttrTypeFactory.create("foo"))
target = ClassFactory.elements(1, extensions=[extension])
self.processor.process_extension(target, extension)
mock_process_dependency_extension.assert_called_once_with(
target, extension)
def test_process_simple_extension_when_source_and_target_are_not_enumerations(
self, mock_copy_attributes):
source = ClassFactory.elements(2)
target = ClassFactory.elements(1)
extension = ExtensionFactory.create()
self.processor.process_simple_extension(source, target, extension)
mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_process_simple_extension_when_target_is_enumeration_and_source_is_not(
self, mock_add_default_attribute, mock_copy_attributes):
extension = ExtensionFactory.create()
source = ClassFactory.elements(2)
target = ClassFactory.enumeration(1, extensions=[extension])
self.processor.process_simple_extension(source, target, extension)
self.assertEqual(0, mock_add_default_attribute.call_count)
self.assertEqual(0, mock_copy_attributes.call_count)
self.assertEqual(0, len(target.extensions))
def test_process_complex_extension_ignores_extension(
self, mock_should_remove_extension, mock_should_flatten_extension):
mock_should_remove_extension.return_value = False
mock_should_flatten_extension.return_value = False
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
source = ClassFactory.create()
self.processor.process_complex_extension(source, target, extension)
self.assertEqual(1, len(target.extensions))
def test_copy_extensions(self):
target = ClassFactory.create(extensions=ExtensionFactory.list(1))
source = ClassFactory.create(extensions=ExtensionFactory.list(2))
link_extension = ExtensionFactory.create()
link_extension.restrictions.max_occurs = 2
ClassUtils.copy_extensions(source, target, link_extension)
self.assertEqual(3, len(target.extensions))
self.assertEqual(2, target.extensions[1].restrictions.max_occurs)
self.assertEqual(2, target.extensions[2].restrictions.max_occurs)
def test_process_complex_extension_copies_attributes(
self, mock_compare_attributes, mock_should_flatten_extension):
mock_should_flatten_extension.return_value = True
extension = ExtensionFactory.create()
target = ClassFactory.create()
source = ClassFactory.create()
self.processor.process_complex_extension(source, target, extension)
mock_compare_attributes.assert_called_once_with(source, target)
mock_should_flatten_extension.assert_called_once_with(
source, target, extension)
def test_build_class_extensions(self, mock_children_extensions):
bar_type = AttrTypeFactory.create(qname="bar")
foo_type = AttrTypeFactory.create(qname="foo")
bar = ExtensionFactory.create(bar_type)
double = ExtensionFactory.create(bar_type)
foo = ExtensionFactory.create(foo_type)
mock_children_extensions.return_value = [bar, double, foo]
self_ext = ExtensionFactory.reference(
qname="{xsdata}something",
restrictions=Restrictions(min_occurs=1, max_occurs=1),
)
item = ClassFactory.create()
element = Element(type="something")
SchemaMapper.build_class_extensions(element, item)
self.assertEqual(3, len(item.extensions))
self.assertCountEqual([bar, self_ext, foo], item.extensions)
def test_replace_attributes_type(self):
extension = ExtensionFactory.create()
target = ClassFactory.elements(2)
target.extensions.append(extension)
ClassExtensionHandler.replace_attributes_type(target, extension)
self.assertEqual(1, len(target.attrs[0].types))
self.assertEqual(1, len(target.attrs[1].types))
self.assertEqual(extension.type, target.attrs[0].types[0])
self.assertEqual(extension.type, target.attrs[1].types[0])
self.assertEqual(0, len(target.extensions))
def test_is_simple_type(self):
obj = ClassFactory.elements(2)
self.assertFalse(obj.is_simple_type)
obj.attrs.pop()
self.assertFalse(obj.is_simple_type)
for tag in SIMPLE_TYPES:
obj.attrs[0].tag = tag
self.assertTrue(obj.is_simple_type)
obj.extensions.append(ExtensionFactory.create())
self.assertFalse(obj.is_simple_type)
def test_process_dependency_extension_with_absent_type(
self,
mock_find_dependency,
mock_process_simple_extension,
mock_process_complex_extension,
):
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
mock_find_dependency.return_value = None
self.processor.process_extension(target, extension)
self.assertEqual(0, len(target.extensions))
self.assertEqual(0, mock_process_simple_extension.call_count)
self.assertEqual(0, mock_process_complex_extension.call_count)
def test_process_complex_extension_removes_extension(
self, mock_should_remove_extension, mock_copy_attributes):
mock_should_remove_extension.return_value = True
extension = ExtensionFactory.create()
target = ClassFactory.elements(1, extensions=[extension])
source = ClassFactory.elements(5)
self.processor.process_complex_extension(source, target, extension)
self.assertEqual(0, len(target.extensions))
self.assertEqual(1, len(target.attrs))
mock_should_remove_extension.assert_called_once_with(source, target)
self.assertEqual(0, mock_copy_attributes.call_count)
def test_process_dependency_extension_with_simple_type(
self,
mock_find_dependency,
mock_process_simple_extension,
mock_process_complex_extension,
):
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
source = ClassFactory.create(tag=Tag.SIMPLE_TYPE)
mock_find_dependency.return_value = source
self.processor.process_extension(target, extension)
self.assertEqual(0, mock_process_complex_extension.call_count)
mock_process_simple_extension.assert_called_once_with(source, target, extension)
def test_add_default_attribute_with_any_type(self):
extension = ExtensionFactory.create(
AttrTypeFactory.native(DataType.ANY_TYPE),
Restrictions(min_occurs=1, max_occurs=1, required=True),
)
item = ClassFactory.create(extensions=[extension])
ClassExtensionHandler.add_default_attribute(item, extension)
expected = AttrFactory.create(
name="@any_element",
default=None,
types=[extension.type.clone()],
tag=Tag.ANY,
namespace="##any",
restrictions=Restrictions(min_occurs=1, max_occurs=1, required=True),
)
self.assertEqual(1, len(item.attrs))
self.assertEqual(0, len(item.extensions))
self.assertEqual(expected, item.attrs[0])
def test_apply_aliases(self):
self.resolver.aliases = {
build_qname("xsdata", "d"): "IamD",
build_qname("xsdata", "a"): "IamA",
}
type_a = AttrTypeFactory.create(qname="{xsdata}a")
type_b = AttrTypeFactory.create(qname="{xsdata}b")
type_c = AttrTypeFactory.create(qname="{xsdata}c")
type_d = AttrTypeFactory.create(qname="{xsdata}d")
obj = ClassFactory.create(
qname="a",
attrs=[
AttrFactory.create(name="a", types=[type_a]),
AttrFactory.create(name="b", types=[type_b]),
AttrFactory.create(name="c", types=[type_a, type_d]),
],
inner=[
ClassFactory.create(
qname="b",
attrs=[
AttrFactory.create(name="c", types=[type_c]),
AttrFactory.create(name="d", types=[type_d]),
AttrFactory.create(
name="compound",
types=[AttrTypeFactory.native(DataType.ANY_TYPE)],
choices=[
AttrFactory.create(name="a",
types=[type_a, type_d]),
],
),
],
)
],
extensions=[ExtensionFactory.create(type_a)],
)
self.resolver.apply_aliases(obj)
self.assertEqual(3, len(obj.attrs))
self.assertEqual(1, len(obj.attrs[0].types))
self.assertEqual(1, len(obj.attrs[1].types))
self.assertEqual(2, len(obj.attrs[2].types))
self.assertEqual("IamA", obj.attrs[0].types[0].alias)
self.assertIsNone(obj.attrs[1].types[0].alias)
self.assertEqual("IamA", obj.attrs[2].types[0].alias)
self.assertEqual("IamD", obj.attrs[2].types[1].alias)
self.assertEqual("IamA", obj.extensions[0].type.alias)
self.assertEqual(1, len(obj.inner))
self.assertEqual(3, len(obj.inner[0].attrs))
self.assertEqual(1, len(obj.inner[0].attrs[0].types))
self.assertEqual(1, len(obj.inner[0].attrs[1].types))
self.assertEqual("IamA",
obj.inner[0].attrs[2].choices[0].types[0].alias)
self.assertEqual("IamD",
obj.inner[0].attrs[2].choices[0].types[1].alias)
self.assertIsNone(obj.inner[0].attrs[0].types[0].alias)
self.assertEqual("IamD", obj.inner[0].attrs[1].types[0].alias)
def test_process_extension_native(self, mock_add_default_attribute):
extension = ExtensionFactory.create()
target = ClassFactory.elements(1)
self.processor.process_native_extension(target, extension)
mock_add_default_attribute.assert_called_once_with(target, extension)
def test_process_simple_extension_with_circular_refence(self):
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
self.processor.process_simple_extension(target, target, extension)
self.assertEqual(0, len(target.extensions))
