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_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_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_message_parts_with_original_message(
self, mock_find_message, mock_create_message_attributes
):
definitions = Definitions
message_name = "foo:bar"
ns_map = {}
message = Message(
name="session",
parts=[
Part(name="token", element="foo:token"),
Part(name="messageId", type="id"),
Part(name="another", type="id"),
],
)
extended = AnyElement()
mock_create_message_attributes.return_value = AttrFactory.list(2)
mock_find_message.return_value = message
actual = DefinitionsMapper.map_binding_message_parts(
definitions, message_name, extended, ns_map
)
self.assertIsInstance(actual, Generator)
self.assertEqual(2, len(list(actual)))
mock_create_message_attributes.assert_called_once_with(message.parts, ns_map)
mock_find_message.assert_called_once_with("bar")
def test_group_fields(self):
target = ClassFactory.create(attrs=AttrFactory.list(2))
target.attrs[0].restrictions.min_occurs = 10
target.attrs[0].restrictions.max_occurs = 15
target.attrs[1].restrictions.min_occurs = 5
target.attrs[1].restrictions.max_occurs = 20
expected = AttrFactory.create(
name="attr_B_Or_attr_C",
tag="Choice",
index=0,
types=[AttrTypeFactory.xs_any()],
choices=[
AttrFactory.create(
tag=target.attrs[0].tag,
name="attr_B",
types=target.attrs[0].types,
),
AttrFactory.create(
tag=target.attrs[1].tag,
name="attr_C",
types=target.attrs[1].types,
),
],
)
expected_res = Restrictions(min_occurs=5, max_occurs=20)
self.sanitizer.group_fields(target, list(target.attrs))
self.assertEqual(1, len(target.attrs))
self.assertEqual(expected, target.attrs[0])
self.assertEqual(expected_res, target.attrs[0].restrictions)
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_process_attribute(self, mock_find):
target = ClassFactory.create(attrs=[
AttrFactory.create(types=[AttrTypeFactory.create("foo")]),
AttrFactory.create(types=[AttrTypeFactory.create("bar")]),
])
mock_find.side_effect = [-1, 2]
first_attr = target.attrs[0]
second_attr = target.attrs[1]
first_attr.restrictions.max_occurs = 2
attr_qname = first_attr.types[0].qname
reference_attrs = AttrFactory.list(2)
self.processor.create_substitutions()
self.processor.substitutions[attr_qname] = reference_attrs
self.processor.process_attribute(target, first_attr)
self.assertEqual(4, len(target.attrs))
self.assertEqual(reference_attrs[0], target.attrs[0])
self.assertIsNot(reference_attrs[0], target.attrs[0])
self.assertEqual(reference_attrs[1], target.attrs[3])
self.assertIsNot(reference_attrs[1], target.attrs[3])
self.assertEqual(2, target.attrs[0].restrictions.max_occurs)
self.assertEqual(2, target.attrs[3].restrictions.max_occurs)
self.processor.process_attribute(target, second_attr)
self.assertEqual(4, len(target.attrs))
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_attribute(self, mock_find):
target = ClassFactory.elements(2)
mock_find.side_effect = [-1, 2]
first_attr = target.attrs[0]
second_attr = target.attrs[1]
first_attr.restrictions.max_occurs = 2
attr_name = first_attr.name
attr_qname = target.source_qname(attr_name)
reference_attrs = AttrFactory.list(2)
self.processor.create_substitutions()
self.processor.substitutions[attr_qname] = reference_attrs
self.processor.process_attribute(target, first_attr)
self.assertEqual(4, len(target.attrs))
self.assertEqual(reference_attrs[0], target.attrs[0])
self.assertIsNot(reference_attrs[0], target.attrs[0])
self.assertEqual(reference_attrs[1], target.attrs[3])
self.assertIsNot(reference_attrs[1], target.attrs[3])
self.assertEqual(2, target.attrs[0].restrictions.max_occurs)
self.assertEqual(2, target.attrs[3].restrictions.max_occurs)
self.processor.process_attribute(target, second_attr)
self.assertEqual(4, len(target.attrs))
def test_add_substitution_attrs(self, mock_find_attribute):
target = ClassFactory.elements(2)
mock_find_attribute.side_effect = [-1, 2]
first_attr = target.attrs[0]
second_attr = target.attrs[1]
first_attr.restrictions.max_occurs = 2
attr_name = first_attr.name
attr_qname = target.source_qname(attr_name)
reference_attrs = AttrFactory.list(2)
self.analyzer.substitutions_index[attr_qname] = reference_attrs
self.analyzer.add_substitution_attrs(target, first_attr)
self.assertEqual(4, len(target.attrs))
self.assertEqual(reference_attrs[0], target.attrs[0])
self.assertIsNot(reference_attrs[0], target.attrs[0])
self.assertEqual(reference_attrs[1], target.attrs[3])
self.assertIsNot(reference_attrs[1], target.attrs[3])
self.assertEqual(2, target.attrs[0].restrictions.max_occurs)
self.assertEqual(2, target.attrs[3].restrictions.max_occurs)
second_attr.wildcard = True
self.analyzer.add_substitution_attrs(target, second_attr)
self.assertEqual(4, len(target.attrs))
self.analyzer.add_substitution_attrs(target, AttrFactory.enumeration())
self.assertEqual(4, len(target.attrs))
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_field_metadata_choices(self):
attr = AttrFactory.create(choices=AttrFactory.list(2, tag=Tag.ELEMENT))
actual = self.filters.field_metadata(attr, "foo", [])
expected = [
{"name": "attr_B", "type": "Type[str]"},
{"name": "attr_C", "type": "Type[str]"},
]
self.assertEqual(expected, actual["choices"])
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_class(
self,
mock_class_name,
mock_process_extension,
mock_process_attributes,
mock_process_enumerations,
):
mock_class_name.side_effect = lambda x: f"@{x}"
type_o = AttrTypeFactory.create(name="o")
type_m = AttrTypeFactory.create(name="m")
type_n = AttrTypeFactory.create(name="n")
a = ClassFactory.create(
name="a",
extensions=[type_m, type_n],
attrs=AttrFactory.list(2, local_type=TagType.EXTENSION),
)
e = ClassFactory.enumeration(2, name="e")
i = ClassFactory.create(
name="i",
extensions=[type_o],
attrs=AttrFactory.list(2, local_type=TagType.EXTENSION),
)
a.inner = [e, i]
generator.process_class(a)
mock_class_name.assert_has_calls(
[mock.call("a"), mock.call("e"),
mock.call("i")])
mock_process_extension.assert_has_calls(
[mock.call(type_o),
mock.call(type_m),
mock.call(type_n)])
mock_process_attributes.assert_has_calls(
[mock.call(i, ["@a", "@i"]),
mock.call(a, ["@a"])])
mock_process_enumerations.assert_called_once_with(e)
def test_process_simple_dependency_with_more_than_one_attribute(self):
source = ClassFactory.create(type=SimpleType,
attrs=AttrFactory.list(2))
target = ClassFactory.elements(1)
attr = target.attrs[0]
attr_type = attr.types[0]
with self.assertRaises(AnalyzerValueError) as cm:
self.processor.process_simple_dependency(source, target, attr,
attr_type)
self.assertEqual("SimpleType with more than one attribute: `class_B`",
str(cm.exception))
def test_flatten_attribute_types_when_source_has_more_than_one_attribute(
self, mock_find_class, mock_logger_warning
):
type_a = AttrTypeFactory.create(name="a")
type_str = AttrTypeFactory.xs_string()
common = ClassFactory.create(name="bar", attrs=AttrFactory.list(2))
mock_find_class.return_value = common
parent = ClassFactory.create()
attr = AttrFactory.create(name="a", types=[type_a])
self.analyzer.flatten_attribute_types(parent, attr)
self.assertEqual([type_str], attr.types)
mock_logger_warning.assert_called_once_with(
"Missing type implementation: %s", common.type.__name__
)
def test_class_references(self):
target = ClassFactory.elements(
2,
inner=ClassFactory.list(2, attrs=AttrFactory.list(1)),
extensions=ExtensionFactory.list(1),
)
actual = ClassAnalyzer.class_references(target)
# +1 target
# +2 attrs
# +2 attr types
# +1 extension
# +1 extension type
# +2 inner classes
# +2 inner classes attrs
# +2 inner classes attr types
self.assertEqual(13, len(actual))
self.assertEqual(id(target), actual[0])
def test_compare_attributes(self):
source = ClassFactory.elements(2)
self.assertEqual(2, ClassUtils.compare_attributes(source, source))
target = ClassFactory.create()
self.assertEqual(0, ClassUtils.compare_attributes(source, target))
target.attrs = [attr.clone() for attr in source.attrs]
self.assertEqual(2, ClassUtils.compare_attributes(source, target))
source.attrs.append(AttrFactory.element())
self.assertEqual(1, ClassUtils.compare_attributes(source, target))
source.attrs = AttrFactory.list(3)
self.assertEqual(0, ClassUtils.compare_attributes(source, target))
self.assertEqual(0, ClassUtils.INCLUDES_NONE)
self.assertEqual(1, ClassUtils.INCLUDES_SOME)
self.assertEqual(2, ClassUtils.INCLUDES_ALL)
def test_build_message_class(self, mock_create_message_attributes):
message = Message(name="bar", parts=[Part()])
message.ns_map["foo"] = "bar"
definitions = Definitions(
messages=[message], target_namespace="xsdata", location="foo.wsdl"
)
port_type_message = PortTypeMessage(message="foo:bar")
attrs = AttrFactory.list(2)
mock_create_message_attributes.return_value = attrs
actual = DefinitionsMapper.build_message_class(definitions, port_type_message)
expected = Class(
qname=build_qname("xsdata", "bar"),
status=Status.PROCESSED,
type=Element,
module="foo",
ns_map=message.ns_map,
attrs=attrs,
)
self.assertEqual(expected, actual)
def test_create_substitutions(self, mock_create_substitution):
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_substitution.side_effect = reference_attrs
self.processor.container.extend(classes)
self.processor.create_substitutions()
expected = {
QName(namespace, "foo"): [reference_attrs[0], reference_attrs[2]],
QName(namespace, "bar"): [reference_attrs[1]],
}
self.assertEqual(expected, self.processor.substitutions)
mock_create_substitution.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 mock_create_attr(*args, **kwargs):
return AttrFactory.list(1)
