def test_find_enum(self): native_type = AttrTypeFactory.create() matching_external = AttrTypeFactory.create("foo") missing_external = AttrTypeFactory.create("bar") enumeration = ClassFactory.enumeration(1, qname="foo") inner = ClassFactory.enumeration(1, qname="foobar") target = ClassFactory.create( attrs=[ AttrFactory.create(types=[ native_type, matching_external, missing_external, ]) ], inner=[inner], ) self.sanitizer.container.extend([target, enumeration]) actual = self.sanitizer.find_enum(native_type) self.assertIsNone(actual) actual = self.sanitizer.find_enum(matching_external) self.assertEqual(enumeration, actual) actual = self.sanitizer.find_enum(missing_external) self.assertIsNone(actual)
def test_process_simple_extension_when_source_and_target_are_enumerations( self, mock_copy_attributes): source = ClassFactory.enumeration(2) target = ClassFactory.enumeration(1) extension = ExtensionFactory.create() self.processor.process_simple_extension(source, target, extension) mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_process_attribute_default_enum(self, mock_find_enum, mock_logger_warning): enum_one = ClassFactory.enumeration(1, qname="{a}root") enum_one.attrs[0].default = "1" enum_one.attrs[0].name = "one" enum_two = ClassFactory.enumeration(1, qname="inner") enum_two.attrs[0].default = "2" enum_two.attrs[0].name = "two" enum_three = ClassFactory.enumeration(1, qname="missing_member") mock_find_enum.side_effect = [ None, enum_one, None, enum_two, enum_three, ] target = ClassFactory.create( qname="target", attrs=[ AttrFactory.create( types=[ AttrTypeFactory.create(), AttrTypeFactory.create(qname="foo"), ], default="1", ), AttrFactory.create( types=[ AttrTypeFactory.create(), AttrTypeFactory.create(qname="bar", forward=True), ], default="2", ), AttrFactory.create(default="3"), ], ) actual = [] for attr in target.attrs: self.sanitizer.process_attribute_default(target, attr) actual.append(attr.default) self.assertEqual(["@enum@{a}root::one", "@enum@inner::two", None], actual) mock_logger_warning.assert_called_once_with( "No enumeration member matched %s.%s default value `%s`", target.name, target.attrs[2].local_name, "3", )
def test_process_enum_extension_with_enum_source(self): source = ClassFactory.enumeration(3) target = ClassFactory.enumeration(2) target.attrs[1].name = source.attrs[2].name extension = ExtensionFactory.reference(source.qname) target.extensions.append(extension) self.processor.container.add(source) self.processor.container.add(target) self.processor.process_dependency_extension(target, extension) self.assertEqual(2, len(target.attrs)) self.assertEqual(0, len(target.extensions)) self.assertEqual(source.attrs[2], target.attrs[1])
def test_process_native_extension_with_enumeration_target( self, mock_replace_attributes_type): extension = ExtensionFactory.create() target = ClassFactory.enumeration(1) self.processor.process_native_extension(target, extension) mock_replace_attributes_type.assert_called_once_with(target, extension)
def test_process_enum_extension_with_complex_source(self): source = ClassFactory.create( tag=Tag.COMPLEX_TYPE, attrs=[ AttrFactory.create(tag=Tag.ATTRIBUTE), AttrFactory.create(tag=Tag.RESTRICTION), ], extensions=ExtensionFactory.list(2), status=Status.PROCESSED, ) target = ClassFactory.enumeration(1) target.attrs[0].default = "Yes" extension = ExtensionFactory.reference(source.qname) target.extensions.append(extension) expected = target.clone() self.processor.container.add(source) self.processor.container.add(target) self.processor.process_dependency_extension(target, extension) expected.attrs = [attr.clone() for attr in source.attrs] expected.extensions = [ext.clone() for ext in source.extensions] expected.attrs[1].default = "Yes" expected.attrs[1].fixed = True self.assertEqual(expected, target) self.assertIsNone(target.attrs[0].default) self.assertFalse(target.attrs[0].fixed) self.assertEqual("Yes", target.attrs[1].default) self.assertTrue(target.attrs[1].fixed)
def test_render_module(self): classes = [ ClassFactory.enumeration(2, help="\n\nI am enum "), ClassFactory.elements(2), ClassFactory.service(2), ] classes[0].attrs[0].help = "I am a member" classes[1].attrs[0].help = "I am a field" resolver = DependenciesResolver() actual = self.generator.render_module(resolver, classes) expected = ("from dataclasses import dataclass, field\n" "from enum import Enum\n" "from typing import Optional\n" "\n" '__NAMESPACE__ = "xsdata"\n' "\n" "\n" "class ClassB(Enum):\n" ' """\n' " I am enum.\n" "\n" " :cvar ATTR_B: I am a member\n" " :cvar ATTR_C:\n" ' """\n' " ATTR_B = None\n" " ATTR_C = None\n" "\n" "\n" "@dataclass\n" "class ClassC:\n" ' """\n' " :ivar attr_d: I am a field\n" " :ivar attr_e:\n" ' """\n' " class Meta:\n" ' name = "class_C"\n' "\n" " attr_d: Optional[str] = field(\n" " default=None,\n" " metadata={\n" ' "name": "attr_D",\n' ' "type": "Element",\n' " }\n" " )\n" " attr_e: Optional[str] = field(\n" " default=None,\n" " metadata={\n" ' "name": "attr_E",\n' ' "type": "Element",\n' " }\n" " )\n" "\n" "\n" "class ClassD:\n" ' attr_f = "None"\n' ' attr_g = "None"\n') self.assertEqual(expected, actual)
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_process_simple_extension_when_source_is_enumeration_and_target_is_not( self, mock_add_default_attribute): source = ClassFactory.enumeration(2) target = ClassFactory.elements(1) extension = ExtensionFactory.create() self.processor.process_simple_extension(source, target, extension) mock_add_default_attribute.assert_called_once_with(target, extension)
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_property_is_enumeration(self): obj = ClassFactory.enumeration(2) self.assertTrue(obj.is_enumeration) obj.attrs.append(AttrFactory.element()) self.assertFalse(obj.is_enumeration) obj.attrs.clear() self.assertFalse(obj.is_enumeration)
def test_process_enum_extension_raises_exception(self): source = ClassFactory.elements(2) target = ClassFactory.enumeration(2) extension = ExtensionFactory.reference(source.qname) target.extensions.append(extension) self.processor.container.add(source) self.processor.container.add(target) with self.assertRaises(CodeGenerationError): self.processor.process_dependency_extension(target, extension)
def test_process_simple_extension_when_target_is_enumeration_and_source_is_not( self, mock_add_default_attribute, mock_copy_attributes): extension = ExtensionFactory.create() source = ClassFactory.elements(2) target = ClassFactory.enumeration(1, extensions=[extension]) self.processor.process_simple_extension(source, target, extension) self.assertEqual(0, mock_add_default_attribute.call_count) self.assertEqual(0, mock_copy_attributes.call_count) self.assertEqual(0, len(target.extensions))
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 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_find_inner(self): obj = ClassFactory.create(qname="{a}parent") first = ClassFactory.create(qname="{a}a") second = ClassFactory.create(qname="{c}c") third = ClassFactory.enumeration(2, qname="{d}d") obj.inner.extend((first, second, third)) with self.assertRaises(CodeGenerationError) as cm: self.assertIsNone(ClassUtils.find_inner(obj, "nope")) self.assertEqual("Missing inner class {a}parent.nope", str(cm.exception)) self.assertEqual(first, ClassUtils.find_inner(obj, "{a}a")) self.assertEqual(second, ClassUtils.find_inner(obj, "{c}c")) self.assertEqual(third, ClassUtils.find_inner(obj, "{d}d"))
def test_build_inner_classes_with_enumeration(self, mock_build_class): inner = ClassFactory.enumeration(2) mock_build_class.return_value = inner enumeration = SimpleType(restriction=Restriction( enumerations=[Enumeration(value="a")])) result = SchemaMapper.build_inner_classes(enumeration, "module", "target_ns") self.assertIsInstance(result, Iterator) self.assertEqual([inner], list(result)) self.assertIsNone(enumeration.name) mock_build_class.assert_called_once_with(enumeration, Tag.SIMPLE_TYPE, "module", "target_ns")
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)
def test_process_enum_extension_with_simple_source(self): qname_type = AttrTypeFactory.native(DataType.QNAME) source = ClassFactory.create( tag=Tag.SIMPLE_TYPE, attrs=[ AttrFactory.create(types=[qname_type], restrictions=Restrictions(length=10)) ], ) target = ClassFactory.enumeration(2) extension = ExtensionFactory.reference(source.qname) target.extensions.append(extension) self.processor.container.add(source) self.processor.container.add(target) self.processor.process_dependency_extension(target, extension) for attr in target.attrs: self.assertIn(qname_type, attr.types) self.assertEqual(10, attr.restrictions.length)
def test_property_should_generate(self): obj = ClassFactory.create(tag=Tag.ELEMENT) self.assertTrue(obj.should_generate) obj = ClassFactory.create(tag=Tag.COMPLEX_TYPE) self.assertTrue(obj.should_generate) obj.attrs.append(AttrFactory.create(tag=Tag.EXTENSION)) self.assertFalse(obj.should_generate) obj = ClassFactory.create(tag=Tag.BINDING_OPERATION) self.assertTrue(obj.should_generate) obj = ClassFactory.create(tag=Tag.BINDING_MESSAGE) self.assertTrue(obj.should_generate) obj = ClassFactory.enumeration(2) self.assertTrue(obj.should_generate) obj = ClassFactory.create(tag=Tag.SIMPLE_TYPE) self.assertFalse(obj.should_generate)