def test_dependencies(self):
obj = ClassFactory.create(
attrs=[
AttrFactory.create(types=[AttrTypeFactory.xs_decimal()]),
AttrFactory.create(types=[
AttrTypeFactory.create(qname=QName(Namespace.XS.uri,
"annotated"),
forward=True)
]),
AttrFactory.create(types=[
AttrTypeFactory.create(
qname=QName(Namespace.XS.uri, "openAttrs")),
AttrTypeFactory.create(
qname=QName(Namespace.XS.uri, "localAttribute")),
]),
],
extensions=[
ExtensionFactory.create(type=AttrTypeFactory.create(
qname=QName(Namespace.XS.uri, "foobar"))),
ExtensionFactory.create(type=AttrTypeFactory.create(
qname=QName(Namespace.XS.uri, "foobar"))),
],
inner=[
ClassFactory.create(attrs=AttrFactory.list(
2, types=AttrTypeFactory.list(1, qname="foo")))
],
)
expected = [
QName("{http://www.w3.org/2001/XMLSchema}openAttrs"),
QName("{http://www.w3.org/2001/XMLSchema}localAttribute"),
QName("{http://www.w3.org/2001/XMLSchema}foobar"),
QName("{xsdata}foo"),
]
self.assertEqual(expected, list(obj.dependencies()))
def test_rename_dependency(self):
attr_type = AttrTypeFactory.create("{foo}bar")
target = ClassFactory.create(
extensions=[
ExtensionFactory.create(),
ExtensionFactory.create(type=attr_type.clone()),
],
attrs=[
AttrFactory.create(),
AttrFactory.create(types=[AttrTypeFactory.create(), attr_type.clone()]),
],
inner=[
ClassFactory.create(
extensions=[ExtensionFactory.create(type=attr_type.clone())],
attrs=[
AttrFactory.create(),
AttrFactory.create(
types=[AttrTypeFactory.create(), attr_type.clone()]
),
],
)
],
)
self.sanitizer.rename_dependency(target, "{foo}bar", "thug")
dependencies = set(target.dependencies())
self.assertNotIn("{foo}bar", dependencies)
self.assertIn("thug", dependencies)
def test_dependencies(self):
obj = ClassFactory.create(
attrs=[
AttrFactory.create(types=[AttrTypeFactory.xs_decimal()]),
AttrFactory.create(
types=[
AttrTypeFactory.create(
qname=build_qname(Namespace.XS.uri, "annotated"),
forward=True,
)
],
choices=[
AttrFactory.create(
name="x",
types=[
AttrTypeFactory.create(qname="choiceAttr"),
AttrTypeFactory.xs_string(),
],
),
AttrFactory.create(
name="x",
types=[
AttrTypeFactory.create(qname="choiceAttrTwo"),
AttrTypeFactory.create(qname="choiceAttrEnum"),
],
),
],
),
AttrFactory.create(types=[
AttrTypeFactory.create(
qname=build_qname(Namespace.XS.uri, "openAttrs")),
AttrTypeFactory.create(
qname=build_qname(Namespace.XS.uri, "localAttribute")),
]),
],
extensions=[
ExtensionFactory.create(type=AttrTypeFactory.create(
qname=build_qname(Namespace.XS.uri, "foobar"))),
ExtensionFactory.create(type=AttrTypeFactory.create(
qname=build_qname(Namespace.XS.uri, "foobar"))),
],
inner=[
ClassFactory.create(attrs=AttrFactory.list(
2, types=AttrTypeFactory.list(1, qname="{xsdata}foo")))
],
)
expected = [
"choiceAttr",
"choiceAttrTwo",
"choiceAttrEnum",
"{http://www.w3.org/2001/XMLSchema}openAttrs",
"{http://www.w3.org/2001/XMLSchema}localAttribute",
"{http://www.w3.org/2001/XMLSchema}foobar",
"{xsdata}foo",
]
self.assertCountEqual(expected, list(obj.dependencies()))
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_merge_redefined_type_with_circular_extension(
self, mock_copy_attributes, mock_copy_extensions
):
source = ClassFactory.create()
target = source.clone()
ext_a = ExtensionFactory.create(type=AttrTypeFactory.create(qname=source.name))
ext_str = ExtensionFactory.create(type=AttrTypeFactory.create(qname="foo"))
target.extensions.append(ext_str)
target.extensions.append(ext_a)
self.validator.merge_redefined_type(source, target)
mock_copy_attributes.assert_called_once_with(source, target, ext_a)
mock_copy_extensions.assert_called_once_with(source, target, ext_a)
def test_merge_redefined_classes_copies_attributes(self, mock_copy_attributes):
class_a = ClassFactory.create()
class_b = ClassFactory.create()
class_c = class_a.clone()
ext_a = ExtensionFactory.create(type=AttrTypeFactory.create(name=class_a.name))
ext_str = ExtensionFactory.create(type=AttrTypeFactory.create(name="foo"))
class_c.extensions.append(ext_a)
class_c.extensions.append(ext_str)
classes = [class_a, class_b, class_c]
self.analyzer.merge_redefined_classes(classes)
self.assertEqual(2, len(classes))
mock_copy_attributes.assert_called_once_with(class_a, class_c, ext_a)
def test_remove_invalid_classes(self):
first = ClassFactory.create(extensions=[
ExtensionFactory.create(type=AttrTypeFactory.xs_bool()),
ExtensionFactory.create(type=AttrTypeFactory.create(name="foo")),
])
second = ClassFactory.create(extensions=[
ExtensionFactory.create(type=AttrTypeFactory.xs_bool()),
])
third = ClassFactory.create()
self.validator.container.extend([first, second, third])
classes = [first, second, third]
self.validator.remove_invalid_classes(classes)
self.assertEqual([second, third], classes)
def test_dependencies(self):
obj = ClassFactory.create(
attrs=[
AttrFactory.create(types=[AttrTypeFactory.xs_decimal()]),
AttrFactory.create(
types=[
AttrTypeFactory.create(name="xs:annotated", forward_ref=True)
]
),
AttrFactory.create(
types=[
AttrTypeFactory.create(name="xs:openAttrs"),
AttrTypeFactory.create(name="xs:localAttribute"),
]
),
],
extensions=ExtensionFactory.list(
1, type=AttrTypeFactory.create(name="xs:localElement")
),
inner=[
ClassFactory.create(
attrs=AttrFactory.list(2, types=AttrTypeFactory.list(1, name="foo"))
)
],
)
expected = {
QName("{http://www.w3.org/2001/XMLSchema}localAttribute"),
QName("{http://www.w3.org/2001/XMLSchema}localElement"),
QName("{http://www.w3.org/2001/XMLSchema}openAttrs"),
QName("{xsdata}foo"),
}
self.assertEqual(expected, obj.dependencies())
def test_process_native_extension_with_enumeration_target(
self, mock_copy_extension_type):
extension = ExtensionFactory.create()
target = ClassFactory.enumeration(1)
self.processor.process_native_extension(target, extension)
mock_copy_extension_type.assert_called_once_with(target, extension)
def test_process_extension_native(self, mock_create_default_attribute):
extension = ExtensionFactory.create()
target = ClassFactory.elements(1)
self.processor.process_native_extension(target, extension)
mock_create_default_attribute.assert_called_once_with(
target, extension)
def test_create_default_attribute_with_any_type(self):
extension = ExtensionFactory.create(
type=AttrTypeFactory.xs_any(),
restrictions=Restrictions(min_occurs=1,
max_occurs=1,
required=True),
)
item = ClassFactory.create(extensions=[extension])
ClassExtensionHandler.create_default_attribute(item, extension)
expected = AttrFactory.create(
name="any_element",
index=0,
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_flatten_extension_native_and_target_enumeration(
self, mock_create_default_attribute):
extension = ExtensionFactory.create()
target = ClassFactory.enumeration(1)
self.analyzer.flatten_extension_native(target, extension)
self.assertEqual(0, mock_create_default_attribute.call_count)
def test_copy_attributes(self, mock_clone_attribute,
mock_copy_inner_classes):
mock_clone_attribute.side_effect = lambda x, y, z: x.clone()
target = ClassFactory.create(attrs=[
AttrFactory.create(name="foo:a"),
AttrFactory.create(name="b")
])
source = ClassFactory.create(attrs=[
AttrFactory.create(name="c", index=sys.maxsize),
AttrFactory.create(name="a"),
AttrFactory.create(name="boo:b"),
AttrFactory.create(name="d"),
])
extension = ExtensionFactory.create(type=AttrTypeFactory.create(
name="foo:foo"))
target.extensions.append(extension)
ClassUtils.copy_attributes(source, target, extension)
self.assertEqual(["foo:a", "b", "d", "c"],
[attr.name for attr in target.attrs])
mock_copy_inner_classes.assert_called_once_with(source, target)
mock_clone_attribute.assert_has_calls([
mock.call(source.attrs[0], extension.restrictions, "foo"),
mock.call(source.attrs[3], extension.restrictions, "foo"),
])
def test_flatten_extension_simple_when_source_and_target_are_not_enumerations(
self, mock_copy_attributes):
source = ClassFactory.elements(2)
target = ClassFactory.elements(1)
extension = ExtensionFactory.create()
self.analyzer.flatten_extension_simple(source, target, extension)
mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_process_simple_extension_when_source_and_target_are_enumerations(
self, mock_copy_attributes):
source = ClassFactory.enumeration(2)
target = ClassFactory.enumeration(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_extension_with_dependency_type(
self, mock_process_dependency_extension):
extension = ExtensionFactory.create(type=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_flatten_extension_native_and_target_no_enumeration(
self, mock_create_default_attribute):
extension = ExtensionFactory.create()
target = ClassFactory.elements(1)
self.analyzer.flatten_extension_native(target, extension)
mock_create_default_attribute.assert_called_once_with(
target, extension)
def test_flatten_extension_with_native_type(self,
mock_flatten_extension_native):
extension = ExtensionFactory.create(type=AttrTypeFactory.xs_string())
target = ClassFactory.elements(1, extensions=[extension])
self.analyzer.flatten_extension(target, extension)
mock_flatten_extension_native.assert_called_once_with(
target, extension)
def test_process_extension(self, mock_type_name):
extension = ExtensionFactory.create(type=AttrTypeFactory.create(
name="foobar"))
generator.process_extension(extension)
mock_type_name.assert_called_once_with(extension.type)
self.assertEqual("oof", extension.type.name)
def test_flatten_extension_with_native_type_and_target_not_enumeration(
self, mock_create_default_attribute
):
extension = ExtensionFactory.create(type=AttrTypeFactory.xs_string())
target = ClassFactory.elements(1, extensions=[extension])
self.analyzer.flatten_extension(target, extension)
mock_create_default_attribute.assert_called_once_with(target, extension)
def test_flatten_extension_with_unknown_extension_type(
self, mock_logger_warning):
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
self.analyzer.flatten_extension(target, extension)
self.assertEqual(0, len(target.extensions))
mock_logger_warning.assert_called_once_with(
"Missing extension type: %s", extension.type.name)
def test_flatten_extension_simple_when_source_is_enumeration_and_target_is_not(
self, mock_create_default_attribute
):
source = ClassFactory.enumeration(2)
target = ClassFactory.elements(1)
extension = ExtensionFactory.create()
self.analyzer.flatten_extension_simple(source, target, extension)
mock_create_default_attribute.assert_called_once_with(target, extension)
def test_flatten_extension_simple_when_target_is_enumeration_and_source_is_not(
self, mock_create_default_attribute, mock_copy_attributes):
extension = ExtensionFactory.create()
source = ClassFactory.elements(2)
target = ClassFactory.enumeration(1, extensions=[extension])
self.analyzer.flatten_extension_simple(source, target, extension)
self.assertEqual(0, mock_create_default_attribute.call_count)
self.assertEqual(0, mock_copy_attributes.call_count)
self.assertEqual(0, len(target.extensions))
def test_process_complex_extension_when_target_includes_some_source_attrs(
self, mock_compare_attributes, mock_copy_attributes):
mock_compare_attributes.return_value = ClassExtensionHandler.INCLUDES_SOME
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_copy_attributes.assert_called_once_with(source, target, extension)
def test_process_complex_extension_when_source_is_strict_type(
self, mock_compare_attributes, mock_copy_attributes):
mock_compare_attributes.return_value = ClassExtensionHandler.INCLUDES_NONE
extension = ExtensionFactory.create()
target = ClassFactory.create()
source = ClassFactory.create(strict_type=True)
self.processor.process_complex_extension(source, target, extension)
mock_compare_attributes.assert_called_once_with(source, target)
mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_copy_extension_type(self):
extension = ExtensionFactory.create()
target = ClassFactory.elements(2)
target.extensions.append(extension)
ClassExtensionHandler.copy_extension_type(target, extension)
self.assertEqual(extension.type, target.attrs[0].types[1])
self.assertEqual(extension.type, target.attrs[1].types[1])
self.assertEqual(0, len(target.extensions))
def test_flatten_extension_complex_when_target_is_abstract(
self, mock_compare_attributes, mock_copy_attributes):
mock_compare_attributes.return_value = self.analyzer.INCLUDES_NONE
extension = ExtensionFactory.create()
target = ClassFactory.create(abstract=True)
source = ClassFactory.create()
self.analyzer.flatten_extension_complex(source, target, extension)
mock_compare_attributes.assert_called_once_with(source, target)
mock_copy_attributes.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")
some_type = AttrTypeFactory.create(qname="{xsdata}something")
bar = ExtensionFactory.create(type=bar_type)
double = ExtensionFactory.create(type=bar_type)
foo = ExtensionFactory.create(type=foo_type)
mock_children_extensions.return_value = [bar, double, foo]
self_ext = ExtensionFactory.create(type=some_type,
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_process_complex_extension_when_target_has_suffix_attr(
self, mock_compare_attributes, mock_copy_attributes):
mock_compare_attributes.return_value = ClassExtensionHandler.INCLUDES_NONE
extension = ExtensionFactory.create()
target = ClassFactory.create()
source = ClassFactory.create()
target.attrs.append(AttrFactory.create(index=sys.maxsize))
self.processor.process_complex_extension(source, target, extension)
mock_compare_attributes.assert_called_once_with(source, target)
mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_flatten_extension_complex_when_target_includes_no_source_attrs(
self, mock_compare_attributes, mock_copy_attributes):
mock_compare_attributes.return_value = self.analyzer.INCLUDES_NONE
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
source = ClassFactory.create()
self.analyzer.flatten_extension_complex(source, target, extension)
mock_compare_attributes.assert_called_once_with(source, target)
self.assertEqual(0, mock_copy_attributes.call_count)
self.assertEqual(1, len(target.extensions))