def test_create_substitutions(self, mock_create_substitution):
ns = "xsdata"
classes = [
ClassFactory.create(
substitutions=[build_qname(ns, "foo"),
build_qname(ns, "bar")],
abstract=True,
),
ClassFactory.create(substitutions=[build_qname(ns, "foo")],
abstract=True),
]
reference_attrs = AttrFactory.list(3)
mock_create_substitution.side_effect = reference_attrs
self.processor.container.extend(classes)
self.processor.create_substitutions()
expected = {
build_qname(ns, "foo"): [reference_attrs[0], reference_attrs[2]],
build_qname(ns, "bar"): [reference_attrs[1]],
}
self.assertEqual(expected, self.processor.substitutions)
mock_create_substitution.assert_has_calls([
mock.call(classes[0]),
mock.call(classes[0]),
mock.call(classes[1])
])
def test_flatten_attribute_types_when_source_has_only_one_attribute(
self, mock_find_class, mock_copy_inner_classes
):
type_a = AttrTypeFactory.create(name="a")
type_b = AttrTypeFactory.create(name="b")
common = ClassFactory.create(
name="bar",
attrs=AttrFactory.list(
1,
name="b",
types=[type_b],
restrictions=RestrictionsFactory.create(required=True, min_occurs=2),
),
)
mock_find_class.return_value = common
parent = ClassFactory.create()
attr = AttrFactory.create(
name="a",
types=[type_a],
restrictions=RestrictionsFactory.create(min_occurs=1),
)
self.analyzer.flatten_attribute_types(parent, attr)
self.assertEqual([type_b], attr.types)
self.assertEqual(
{"required": True, "min_occurs": 2}, attr.restrictions.asdict()
)
mock_find_class.assert_called_once_with(parent.source_qname(type_a.name))
mock_copy_inner_classes.assert_called_once_with(common, parent)
def test_map_binding_operation_messages_with_style_rpc(
self, mock_build_envelope_class, mock_build_message_class
):
definitions = Definitions()
operation = BindingOperation()
port_operation = PortTypeOperation()
name = "Add"
namespace = "someNS"
target = ClassFactory.create()
message = ClassFactory.create()
style = "rpc"
mock_build_message_class.return_value = message
mock_build_envelope_class.return_value = target
operation.input = BindingMessage()
port_operation.input = PortTypeMessage()
result = DefinitionsMapper.map_binding_operation_messages(
definitions, operation, port_operation, name, style, namespace
)
self.maxDiff = None
self.assertEqual([message, target], list(result))
mock_build_message_class.assert_called_once_with(
definitions, port_operation.input
)
mock_build_envelope_class.assert_called_once_with(
definitions,
operation.input,
port_operation.input,
f"{name}_input",
style,
namespace,
)
def test_create_substitutions_index(self, mock_create_reference_attribute):
classes = [
ClassFactory.create(substitutions=["foo", "bar"], abstract=True),
ClassFactory.create(substitutions=["foo"], abstract=True),
]
namespace = classes[0].source_namespace
reference_attrs = AttrFactory.list(3)
mock_create_reference_attribute.side_effect = reference_attrs
self.analyzer.create_substitutions_index(classes)
expected = {
QName(namespace, "foo"): [reference_attrs[0], reference_attrs[2]],
QName(namespace, "bar"): [reference_attrs[1]],
}
self.assertEqual(expected, self.analyzer.substitutions_index)
self.assertFalse(classes[0].abstract)
self.assertFalse(classes[1].abstract)
mock_create_reference_attribute.assert_has_calls(
[
mock.call(classes[0], classes[0].source_qname("foo")),
mock.call(classes[0], classes[0].source_qname("bar")),
mock.call(classes[1], classes[1].source_qname("foo")),
]
)
def test_class_depends_on(self, mock_dependencies, mock_find_class):
source = ClassFactory.create()
target = ClassFactory.create()
another = ClassFactory.create()
find_classes = {QName("a"): another, QName("b"): target}
mock_find_class.side_effect = lambda x, condition: find_classes.get(x)
mock_dependencies.side_effect = [
[QName(x) for x in "cde"],
[QName(x) for x in "abc"],
[QName(x) for x in "xy"],
]
self.assertFalse(self.analyzer.class_depends_on(source, target))
self.assertTrue(self.analyzer.class_depends_on(source, target))
mock_find_class.assert_has_calls(
[
mock.call(QName("c"), condition=None),
mock.call(QName("d"), condition=None),
mock.call(QName("e"), condition=None),
mock.call(QName("a"), condition=None),
mock.call(QName("x"), condition=None),
mock.call(QName("y"), condition=None),
mock.call(QName("b"), condition=None),
]
)
def test_copy_inner_classes(self):
source = ClassFactory.create(
inner=ClassFactory.list(2, package="a", module="b"))
target = ClassFactory.create()
ClassUtils.copy_inner_classes(source, target) # All good copy all
self.assertEqual(2, len(target.inner))
ClassUtils.copy_inner_classes(source,
target) # Inner classes exist skip
self.assertEqual(2, len(target.inner))
source.inner.append(target)
attr = AttrFactory.create(types=[
AttrTypeFactory.create(name=target.name, forward=True),
AttrTypeFactory.create(name=target.name, forward=False),
AttrTypeFactory.create(name="foobar"),
])
target.attrs.append(attr)
ClassUtils.copy_inner_classes(source,
target) # Inner class matches target
self.assertEqual(2, len(target.inner))
for inner in target.inner:
self.assertEqual(target.package, inner.package)
self.assertEqual(target.module, inner.module)
self.assertTrue(attr.types[0].circular)
self.assertFalse(attr.types[1].circular)
self.assertFalse(attr.types[2].circular)
def test_from_list(self):
classes = [
ClassFactory.create(qname="{xsdata}foo", type=Element),
ClassFactory.create(qname="{xsdata}foo", type=ComplexType),
ClassFactory.create(qname="{xsdata}foobar", type=ComplexType),
]
container = ClassContainer.from_list(classes)
expected = {
"{xsdata}foo": classes[:2],
"{xsdata}foobar": classes[2:],
}
self.assertEqual(2, len(container))
self.assertEqual(expected, container)
self.assertEqual(
[
"AttributeGroupHandler",
"ClassExtensionHandler",
"AttributeEnumUnionHandler",
"AttributeSubstitutionHandler",
"AttributeTypeHandler",
"AttributeMergeHandler",
"AttributeMixedContentHandler",
"AttributeMismatchHandler",
],
[x.__class__.__name__ for x in container.processors],
)
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(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_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_render(
self,
mock_render_module,
mock_render_package,
):
classes = [
ClassFactory.create(package="foo.bar"),
ClassFactory.create(package="bar.foo"),
ClassFactory.create(package="thug.life"),
]
mock_render_module.return_value = "module"
mock_render_package.return_value = "package"
iterator = DataclassGenerator().render(classes)
cwd = Path.cwd()
actual = [(out.path, out.title, out.source) for out in iterator]
expected = [
(cwd.joinpath("foo/bar/__init__.py"), "init", "package"),
(cwd.joinpath("foo/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("bar/foo/__init__.py"), "init", "package"),
(cwd.joinpath("bar/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("thug/life/__init__.py"), "init", "package"),
(cwd.joinpath("thug/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("foo/bar/tests.py"), "foo.bar.tests", "module"),
(cwd.joinpath("bar/foo/tests.py"), "bar.foo.tests", "module"),
(cwd.joinpath("thug/life/tests.py"), "thug.life.tests", "module"),
]
self.assertEqual(expected, actual)
mock_render_package.assert_has_calls([mock.call([x]) for x in classes])
mock_render_module.assert_has_calls(
[mock.call(mock.ANY, [x]) for x in classes])
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_sanitize_attribute_names(self):
obj = ClassFactory.create(attrs=[
AttrFactory.create(name="a", xml_type=XmlType.ELEMENT),
AttrFactory.create(name="a", xml_type=XmlType.ATTRIBUTE),
AttrFactory.create(name="b", xml_type=XmlType.ATTRIBUTE),
])
generator.sanitize_attribute_names(obj)
self.assertEqual("a", obj.attrs[0].name)
self.assertEqual("a_attribute", obj.attrs[1].name)
self.assertEqual("b", obj.attrs[2].name)
obj = ClassFactory.create(attrs=[
AttrFactory.create(name="a", xml_type=XmlType.ELEMENT),
AttrFactory.create(name="a", xml_type=XmlType.ELEMENT),
])
generator.sanitize_attribute_names(obj)
self.assertEqual("a", obj.attrs[0].name)
self.assertEqual("a_element", obj.attrs[1].name)
obj = ClassFactory.create(attrs=[
AttrFactory.create(name="a", xml_type=XmlType.ATTRIBUTE),
AttrFactory.create(name="a", xml_type=XmlType.ATTRIBUTE),
])
generator.sanitize_attribute_names(obj)
self.assertEqual("a_attribute", obj.attrs[0].name)
self.assertEqual("a", obj.attrs[1].name)
def test_rename_classes_protects_single_element(self, mock_rename_class):
classes = [
ClassFactory.create(qname="a", type=Element),
ClassFactory.create(qname="a", type=ComplexType),
]
self.sanitizer.rename_classes(classes)
mock_rename_class.assert_called_once_with(classes[1])
def test_property_is_complex(self):
obj = ClassFactory.create(type=xsd.Element)
self.assertTrue(obj.is_complex)
obj = ClassFactory.create(type=xsd.ComplexType)
self.assertTrue(obj.is_complex)
obj = ClassFactory.create(type=xsd.SimpleType)
self.assertFalse(obj.is_complex)
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_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_property_is_simple(self):
obj = ClassFactory.create(type=Element)
self.assertFalse(obj.is_simple)
obj.abstract = True
self.assertTrue(obj.is_simple)
obj = ClassFactory.create(type=SimpleType)
self.assertTrue(obj.is_simple)
def test_group_fields_limit_name(self):
target = ClassFactory.create(attrs=AttrFactory.list(3))
self.sanitizer.group_fields(target, list(target.attrs))
self.assertEqual(1, len(target.attrs))
self.assertEqual("attr_B_Or_attr_C_Or_attr_D", target.attrs[0].name)
target = ClassFactory.create(attrs=AttrFactory.list(4))
self.sanitizer.group_fields(target, list(target.attrs))
self.assertEqual("choice", target.attrs[0].name)
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_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_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_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_find_attr_type(self, mock_find_class):
target = ClassFactory.create()
type_a = AttrTypeFactory.create()
source = ClassFactory.create()
mock_find_class.return_value = source
actual = self.analyzer.find_attr_type(target, type_a)
self.assertEqual(source, actual)
mock_find_class.assert_called_once_with(
source.source_qname(type_a.name))
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))
def test_find_dependency(self):
attr_type = AttrTypeFactory.create(qname="a")
self.assertIsNone(self.processor.find_dependency(attr_type))
complex = ClassFactory.create(qname="a", type=ComplexType)
self.processor.container.add(complex)
self.assertEqual(complex, self.processor.find_dependency(attr_type))
simple = ClassFactory.create(qname="a", type=SimpleType)
self.processor.container.add(simple)
self.assertEqual(simple, self.processor.find_dependency(attr_type))
def test_flatten_extension_complex_when_source_depends_on_target(
self, mock_compare_attributes, mock_class_depends_on_class, mock_copy_attributes
):
mock_compare_attributes.return_value = self.analyzer.INCLUDES_SOME
mock_class_depends_on_class.return_value = True
extension = ExtensionFactory.create()
target = ClassFactory.create()
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_flatten_extension_with_simple_source_extension(
self, mock_find_class, mock_flatten_extension_simple
):
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
source = ClassFactory.create()
mock_find_class.return_value = source
self.analyzer.flatten_extension(target, extension)
type_qname = target.source_qname(extension.type.name)
mock_find_class.assert_called_once_with(type_qname)
mock_flatten_extension_simple.assert_called_once_with(source, target, extension)
def test_attr_depends_one(self, mock_find_class, mock_class_depends_on):
target = ClassFactory.create()
source = ClassFactory.create()
attr_type = AttrTypeFactory.create()
mock_find_class.side_effect = [None, target, source]
mock_class_depends_on.return_value = True
self.assertFalse(self.analyzer.attr_depends_on(attr_type, target))
self.assertTrue(self.analyzer.attr_depends_on(attr_type, target))
self.assertTrue(self.analyzer.attr_depends_on(attr_type, target))
mock_class_depends_on.assert_called_once_with(source, target)
def test_flatten_extension_complex_when_target_has_suffix_attr(
self, mock_compare_attributes, mock_class_depends_on_class, mock_copy_attributes
):
mock_compare_attributes.return_value = self.analyzer.INCLUDES_SOME
mock_class_depends_on_class.return_value = False
extension = ExtensionFactory.create()
target = ClassFactory.create()
source = ClassFactory.create()
target.attrs.append(AttrFactory.create(index=sys.maxsize))
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)
