class ClassContainerTests(FactoryTestCase):
def setUp(self):
super().setUp()
self.container = ClassContainer()
def test_from_list(self):
classes = [
ClassFactory.create(qname="foo", type=Element),
ClassFactory.create(qname="foo", type=ComplexType),
ClassFactory.create(qname="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)
@mock.patch.object(ClassContainer, "process_class")
def test_find(self, mock_process_class):
class_a = ClassFactory.create(qname="a")
class_b = ClassFactory.create(qname="b", status=Status.PROCESSED)
class_c = ClassFactory.enumeration(2,
qname="b",
status=Status.PROCESSING)
self.container.extend([class_a, class_b, class_c])
self.assertIsNone(self.container.find(QName("nope")))
self.assertEqual(class_a, self.container.find(class_a.qname))
self.assertEqual(class_b, self.container.find(class_b.qname))
self.assertEqual(
class_c,
self.container.find(class_b.qname, lambda x: x.is_enumeration),
)
mock_process_class.assert_called_once_with(class_a)
@mock.patch.object(ClassContainer, "process_class")
def test_find_repeat_on_condition_and_not_processed(
self, mock_process_class):
first = ClassFactory.elements(2, qname="a")
second = ClassFactory.elements(2, qname="a")
self.container.extend([first, second])
def process_class(x: Class):
x.status = Status.PROCESSED
if x is first:
first.attrs.clear()
mock_process_class.side_effect = process_class
self.assertEqual(
second,
self.container.find(first.qname, lambda x: len(x.attrs) == 2),
)
class ClassContainerTests(FactoryTestCase):
def setUp(self):
super().setUp()
self.container = ClassContainer()
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],
)
@mock.patch.object(ClassContainer, "process_class")
def test_find(self, mock_process_class):
def process_class(x: Class):
x.status = Status.PROCESSED
class_a = ClassFactory.create(qname="a")
class_b = ClassFactory.create(qname="b", status=Status.PROCESSED)
class_c = ClassFactory.enumeration(2, qname="b", status=Status.PROCESSING)
mock_process_class.side_effect = process_class
self.container.extend([class_a, class_b, class_c])
self.assertIsNone(self.container.find("nope"))
self.assertEqual(class_a, self.container.find(class_a.qname))
self.assertEqual(class_b, self.container.find(class_b.qname))
self.assertEqual(
class_c, self.container.find(class_b.qname, lambda x: x.is_enumeration)
)
mock_process_class.assert_called_once_with(class_a)
@mock.patch.object(ClassContainer, "process_class")
def test_find_inner(self, mock_process_class):
obj = ClassFactory.create()
first = ClassFactory.create(qname="{a}a")
second = ClassFactory.enumeration(2, qname="{a}a")
third = ClassFactory.create(qname="{c}c", status=Status.PROCESSED)
fourth = ClassFactory.enumeration(2, qname="{d}d", status=Status.PROCESSING)
obj.inner.extend((first, second, third, fourth))
def process_class(x: Class):
x.status = Status.PROCESSED
def is_enum(x: Class):
return x.is_enumeration
mock_process_class.side_effect = process_class
self.assertIsNone(self.container.find_inner(obj, "nope"))
self.assertEqual(first, self.container.find_inner(obj, "a"))
self.assertEqual(second, self.container.find_inner(obj, "a", is_enum))
self.assertEqual(third, self.container.find_inner(obj, "c"))
self.assertEqual(fourth, self.container.find_inner(obj, "d", is_enum))
mock_process_class.assert_has_calls([mock.call(first), mock.call(second)])
def test_process(self):
target = ClassFactory.create(inner=ClassFactory.list(2))
self.container.add(target)
self.container.process_class(target)
self.assertEqual(Status.PROCESSED, target.status)
self.assertEqual(Status.PROCESSED, target.inner[0].status)
self.assertEqual(Status.PROCESSED, target.inner[1].status)
@mock.patch.object(Class, "should_generate", new_callable=mock.PropertyMock)
def test_filter_classes(self, mock_class_should_generate):
mock_class_should_generate.side_effect = [True, False, False, True, False]
classes = ClassFactory.list(5)
container = ClassContainer.from_list(classes)
expected = [
classes[0],
classes[3],
]
container.filter_classes()
self.assertEqual(expected, container.class_list)
@mock.patch.object(Class, "should_generate", new_callable=mock.PropertyMock)
def test_filter_classes_with_only_simple_types(self, mock_class_should_generate):
mock_class_should_generate.return_value = False
classes = [ClassFactory.enumeration(2), ClassFactory.create(type=SimpleType)]
container = ClassContainer.from_list(classes)
container.filter_classes()
self.assertEqual(classes, container.class_list)
class ClassContainerTests(FactoryTestCase):
def setUp(self):
super().setUp()
self.container = ClassContainer()
def test_initialize(self):
classes = [
ClassFactory.create(qname="{xsdata}foo", tag=Tag.ELEMENT),
ClassFactory.create(qname="{xsdata}foo", tag=Tag.COMPLEX_TYPE),
ClassFactory.create(qname="{xsdata}foobar", tag=Tag.COMPLEX_TYPE),
]
container = ClassContainer()
container.extend(classes)
expected = {
"{xsdata}foo": classes[:2],
"{xsdata}foobar": classes[2:],
}
self.assertEqual(2, len(container.data))
self.assertEqual(expected, container.data)
self.assertEqual(
[
"AttributeGroupHandler",
"ClassExtensionHandler",
"ClassEnumerationHandler",
"AttributeSubstitutionHandler",
"AttributeTypeHandler",
"AttributeMergeHandler",
"AttributeMixedContentHandler",
"AttributeSanitizerHandler",
],
[x.__class__.__name__ for x in container.processors],
)
@mock.patch.object(ClassContainer, "process_class")
def test_find(self, mock_process_class):
def process_class(x: Class):
x.status = Status.PROCESSED
class_a = ClassFactory.create(qname="a")
class_b = ClassFactory.create(qname="b", status=Status.PROCESSED)
class_c = ClassFactory.enumeration(2,
qname="b",
status=Status.PROCESSING)
mock_process_class.side_effect = process_class
self.container.extend([class_a, class_b, class_c])
self.assertIsNone(self.container.find("nope"))
self.assertEqual(class_a, self.container.find(class_a.qname))
self.assertEqual(class_b, self.container.find(class_b.qname))
self.assertEqual(
class_c,
self.container.find(class_b.qname, lambda x: x.is_enumeration))
mock_process_class.assert_called_once_with(class_a)
@mock.patch.object(ClassContainer, "process_class")
def test_find_inner(self, mock_process_class):
obj = ClassFactory.create()
first = ClassFactory.create(qname="{a}a")
second = ClassFactory.create(qname="{a}b", status=Status.PROCESSED)
obj.inner.extend((first, second))
def process_class(x: Class):
x.status = Status.PROCESSED
mock_process_class.side_effect = process_class
self.assertEqual(first, self.container.find_inner(obj, "{a}a"))
self.assertEqual(second, self.container.find_inner(obj, "{a}b"))
mock_process_class.assert_called_once_with(first)
def test_process(self):
target = ClassFactory.create(inner=ClassFactory.list(2))
self.container.add(target)
self.container.process_class(target)
self.assertEqual(Status.PROCESSED, target.status)
self.assertEqual(Status.PROCESSED, target.inner[0].status)
self.assertEqual(Status.PROCESSED, target.inner[1].status)
@mock.patch.object(Class,
"should_generate",
new_callable=mock.PropertyMock)
def test_filter_classes(self, mock_class_should_generate):
mock_class_should_generate.side_effect = [
True, False, False, True, False
]
classes = ClassFactory.list(5)
container = ClassContainer()
container.extend(classes)
expected = [
classes[0],
classes[3],
]
container.filter_classes()
self.assertEqual(expected, container.class_list)
@mock.patch.object(Class,
"should_generate",
new_callable=mock.PropertyMock)
def test_filter_classes_with_only_simple_types(self,
mock_class_should_generate):
mock_class_should_generate.return_value = False
classes = [ClassFactory.enumeration(2), ClassFactory.simple_type()]
container = ClassContainer()
container.extend(classes)
container.filter_classes()
self.assertEqual(classes, container.class_list)
class ClassEnumerationHandlerTests(FactoryTestCase):
def setUp(self):
super().setUp()
self.root_enum = ClassFactory.enumeration(2)
self.inner_enum = ClassFactory.enumeration(2)
self.target = ClassFactory.create(attrs=[
AttrFactory.create(
name="value",
tag=Tag.UNION,
types=[
AttrTypeFactory.create(qname=self.root_enum.qname),
AttrTypeFactory.create(qname=self.inner_enum.qname,
forward=True),
],
),
])
self.target.inner.append(self.inner_enum)
self.container = ClassContainer()
self.container.add(self.target)
self.container.add(self.root_enum)
self.processor = ClassEnumerationHandler(container=self.container)
def test_filter(self):
target = ClassFactory.elements(2)
self.processor.process(target)
self.assertEqual(2, len(target.attrs))
target.attrs.append(AttrFactory.enumeration())
self.processor.process(target)
self.assertEqual(1, len(target.attrs))
self.assertTrue(target.attrs[0].is_enumeration)
def test_flatten_skip_if_class_has_more_than_one_attribute(self):
self.target.attrs.append(AttrFactory.create())
self.processor.process(self.target)
self.assertFalse(self.target.is_enumeration)
self.assertEqual(2, len(self.target.attrs))
def test_flatten_skip_when_attribute_tag_is_not_union(self):
self.target.attrs[0].tag = Tag.ELEMENT
self.processor.process(self.target)
self.assertFalse(self.target.is_enumeration)
def test_flatten_skip_when_types_is_not_enumeration_union(self):
self.target.attrs[0].types.append(AttrTypeFactory.native(DataType.INT))
self.processor.process(self.target)
self.assertFalse(self.target.is_enumeration)
def test_flatten_merges_enumeration_unions(self):
self.processor.process(self.target)
self.assertTrue(self.target.is_enumeration)
expected = self.root_enum.attrs + self.inner_enum.attrs
self.assertEqual(expected, self.target.attrs)
self.assertEqual(0, len(self.target.inner))
def test_promote(self):
target = ClassFactory.elements(2)
inner = ClassFactory.enumeration(3)
target.inner.append(inner)
target.inner.append(ClassFactory.simple_type()) # Irrelevant
attr_type = AttrTypeFactory.create(qname=inner.qname, forward=True)
target.attrs[0].types.append(attr_type.clone())
target.attrs[1].types.append(attr_type.clone())
self.container.add(target)
self.assertEqual(3, len(self.container.data))
self.processor.process(target)
new_qname = build_qname(inner.target_namespace,
f"{target.name}_{inner.name}")
self.assertEqual(4, len(self.container.data))
new_inner = self.container.find(new_qname)
self.assertEqual(1, len(target.inner))
self.assertNotEqual(new_inner.qname, inner.qname)
self.assertEqual(new_inner.attrs, inner.attrs)
self.assertEqual(new_inner.qname, target.attrs[0].types[1].qname)
self.assertEqual(new_inner.qname, target.attrs[1].types[1].qname)
self.assertFalse(target.attrs[0].types[1].forward)
self.assertFalse(target.attrs[1].types[1].forward)
