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)
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)
def test_process_dependency_type_with_simple_type(
self, mock_find_dependency, mock_copy_attribute_properties):
simple = ClassFactory.simple_type()
target = ClassFactory.create()
attr = AttrFactory.create()
attr_type = attr.types[0]
mock_find_dependency.return_value = simple
self.processor.process_dependency_type(target, attr, attr_type)
mock_copy_attribute_properties.assert_called_once_with(
simple, target, attr, attr_type)
def test_process_dependency_type_with_enumeration_type(self, mock_find_dependency):
enumeration = ClassFactory.enumeration(2)
enumeration.attrs[1].restrictions.format = "base16"
mock_find_dependency.return_value = enumeration
target = ClassFactory.simple_type()
attr = target.attrs[0]
attr.types[0] = AttrTypeFactory.create(qname=enumeration.qname)
self.processor.process_dependency_type(target, attr, attr.types[0])
self.assertEqual("base16", attr.restrictions.format)
def test_process_inner_type_with_simple_type(
self, mock_copy_attribute_properties, mock_update_restrictions):
attr = AttrFactory.create(
types=[AttrTypeFactory.create(qname="{bar}a")])
inner = ClassFactory.simple_type(qname="{bar}a",
status=Status.PROCESSED)
target = ClassFactory.create(inner=[inner])
self.processor.process_inner_type(target, attr, attr.types[0])
self.assertNotIn(inner, target.inner)
self.assertEqual(0, mock_update_restrictions.call_count)
mock_copy_attribute_properties.assert_called_once_with(
inner, target, attr, attr.types[0])
