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])