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_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_operation_messages_with_style_rpc( self, mock_build_envelope_class, mock_build_message_class ): definitions = Definitions() operation = BindingOperation() port_operation = PortTypeOperation() name = "Add" namespace = "someNS" target = ClassFactory.create() message = ClassFactory.create() style = "rpc" mock_build_message_class.return_value = message mock_build_envelope_class.return_value = target operation.input = BindingMessage() port_operation.input = PortTypeMessage() result = DefinitionsMapper.map_binding_operation_messages( definitions, operation, port_operation, name, style, namespace ) self.maxDiff = None self.assertEqual([message, target], list(result)) mock_build_message_class.assert_called_once_with( definitions, port_operation.input ) mock_build_envelope_class.assert_called_once_with( definitions, operation.input, port_operation.input, f"{name}_input", style, namespace, )
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_class_depends_on(self, mock_dependencies, mock_find_class): source = ClassFactory.create() target = ClassFactory.create() another = ClassFactory.create() find_classes = {QName("a"): another, QName("b"): target} mock_find_class.side_effect = lambda x, condition: find_classes.get(x) mock_dependencies.side_effect = [ [QName(x) for x in "cde"], [QName(x) for x in "abc"], [QName(x) for x in "xy"], ] self.assertFalse(self.analyzer.class_depends_on(source, target)) self.assertTrue(self.analyzer.class_depends_on(source, target)) mock_find_class.assert_has_calls( [ mock.call(QName("c"), condition=None), mock.call(QName("d"), condition=None), mock.call(QName("e"), condition=None), mock.call(QName("a"), condition=None), mock.call(QName("x"), condition=None), mock.call(QName("y"), condition=None), mock.call(QName("b"), condition=None), ] )
def test_copy_inner_classes(self): source = ClassFactory.create( inner=ClassFactory.list(2, package="a", module="b")) target = ClassFactory.create() ClassUtils.copy_inner_classes(source, target) # All good copy all self.assertEqual(2, len(target.inner)) ClassUtils.copy_inner_classes(source, target) # Inner classes exist skip self.assertEqual(2, len(target.inner)) source.inner.append(target) attr = AttrFactory.create(types=[ AttrTypeFactory.create(name=target.name, forward=True), AttrTypeFactory.create(name=target.name, forward=False), AttrTypeFactory.create(name="foobar"), ]) target.attrs.append(attr) ClassUtils.copy_inner_classes(source, target) # Inner class matches target self.assertEqual(2, len(target.inner)) for inner in target.inner: self.assertEqual(target.package, inner.package) self.assertEqual(target.module, inner.module) self.assertTrue(attr.types[0].circular) self.assertFalse(attr.types[1].circular) self.assertFalse(attr.types[2].circular)
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], )
def test_rename_dependency(self): attr_type = AttrTypeFactory.create("{foo}bar") target = ClassFactory.create( extensions=[ ExtensionFactory.create(), ExtensionFactory.create(type=attr_type.clone()), ], attrs=[ AttrFactory.create(), AttrFactory.create(types=[AttrTypeFactory.create(), attr_type.clone()]), ], inner=[ ClassFactory.create( extensions=[ExtensionFactory.create(type=attr_type.clone())], attrs=[ AttrFactory.create(), AttrFactory.create( types=[AttrTypeFactory.create(), attr_type.clone()] ), ], ) ], ) self.sanitizer.rename_dependency(target, "{foo}bar", "thug") dependencies = set(target.dependencies()) self.assertNotIn("{foo}bar", dependencies) self.assertIn("thug", dependencies)
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_copy_attributes(self, mock_clone_attribute, mock_copy_inner_classes): mock_clone_attribute.side_effect = lambda x, y, z: x.clone() target = ClassFactory.create(attrs=[ AttrFactory.create(name="foo:a"), AttrFactory.create(name="b") ]) source = ClassFactory.create(attrs=[ AttrFactory.create(name="c", index=sys.maxsize), AttrFactory.create(name="a"), AttrFactory.create(name="boo:b"), AttrFactory.create(name="d"), ]) extension = ExtensionFactory.create(type=AttrTypeFactory.create( name="foo:foo")) target.extensions.append(extension) ClassUtils.copy_attributes(source, target, extension) self.assertEqual(["foo:a", "b", "d", "c"], [attr.name for attr in target.attrs]) mock_copy_inner_classes.assert_called_once_with(source, target) mock_clone_attribute.assert_has_calls([ mock.call(source.attrs[0], extension.restrictions, "foo"), mock.call(source.attrs[3], extension.restrictions, "foo"), ])
def test_render( self, mock_render_module, mock_render_package, ): classes = [ ClassFactory.create(package="foo.bar"), ClassFactory.create(package="bar.foo"), ClassFactory.create(package="thug.life"), ] mock_render_module.return_value = "module" mock_render_package.return_value = "package" iterator = DataclassGenerator().render(classes) cwd = Path.cwd() actual = [(out.path, out.title, out.source) for out in iterator] expected = [ (cwd.joinpath("foo/bar/__init__.py"), "init", "package"), (cwd.joinpath("foo/__init__.py"), "init", "# nothing here\n"), (cwd.joinpath("bar/foo/__init__.py"), "init", "package"), (cwd.joinpath("bar/__init__.py"), "init", "# nothing here\n"), (cwd.joinpath("thug/life/__init__.py"), "init", "package"), (cwd.joinpath("thug/__init__.py"), "init", "# nothing here\n"), (cwd.joinpath("foo/bar/tests.py"), "foo.bar.tests", "module"), (cwd.joinpath("bar/foo/tests.py"), "bar.foo.tests", "module"), (cwd.joinpath("thug/life/tests.py"), "thug.life.tests", "module"), ] self.assertEqual(expected, actual) mock_render_package.assert_has_calls([mock.call([x]) for x in classes]) mock_render_module.assert_has_calls( [mock.call(mock.ANY, [x]) for x in classes])
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_sanitize_attribute_names(self): obj = ClassFactory.create(attrs=[ AttrFactory.create(name="a", xml_type=XmlType.ELEMENT), AttrFactory.create(name="a", xml_type=XmlType.ATTRIBUTE), AttrFactory.create(name="b", xml_type=XmlType.ATTRIBUTE), ]) generator.sanitize_attribute_names(obj) self.assertEqual("a", obj.attrs[0].name) self.assertEqual("a_attribute", obj.attrs[1].name) self.assertEqual("b", obj.attrs[2].name) obj = ClassFactory.create(attrs=[ AttrFactory.create(name="a", xml_type=XmlType.ELEMENT), AttrFactory.create(name="a", xml_type=XmlType.ELEMENT), ]) generator.sanitize_attribute_names(obj) self.assertEqual("a", obj.attrs[0].name) self.assertEqual("a_element", obj.attrs[1].name) obj = ClassFactory.create(attrs=[ AttrFactory.create(name="a", xml_type=XmlType.ATTRIBUTE), AttrFactory.create(name="a", xml_type=XmlType.ATTRIBUTE), ]) generator.sanitize_attribute_names(obj) self.assertEqual("a_attribute", obj.attrs[0].name) self.assertEqual("a", obj.attrs[1].name)
def test_rename_classes_protects_single_element(self, mock_rename_class): classes = [ ClassFactory.create(qname="a", type=Element), ClassFactory.create(qname="a", type=ComplexType), ] self.sanitizer.rename_classes(classes) mock_rename_class.assert_called_once_with(classes[1])
def test_property_is_complex(self): obj = ClassFactory.create(type=xsd.Element) self.assertTrue(obj.is_complex) obj = ClassFactory.create(type=xsd.ComplexType) self.assertTrue(obj.is_complex) obj = ClassFactory.create(type=xsd.SimpleType) self.assertFalse(obj.is_complex)
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_complex_extension_when_target_includes_some_source_attrs( self, mock_compare_attributes, mock_copy_attributes): mock_compare_attributes.return_value = ClassExtensionHandler.INCLUDES_SOME extension = ExtensionFactory.create() target = ClassFactory.create() source = ClassFactory.create() self.processor.process_complex_extension(source, target, extension) mock_compare_attributes.assert_called_once_with(source, target) mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_property_is_simple(self): obj = ClassFactory.create(type=Element) self.assertFalse(obj.is_simple) obj.abstract = True self.assertTrue(obj.is_simple) obj = ClassFactory.create(type=SimpleType) self.assertTrue(obj.is_simple)
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_flatten_extension_complex_when_target_is_abstract( self, mock_compare_attributes, mock_copy_attributes): mock_compare_attributes.return_value = self.analyzer.INCLUDES_NONE extension = ExtensionFactory.create() target = ClassFactory.create(abstract=True) source = ClassFactory.create() self.analyzer.flatten_extension_complex(source, target, extension) mock_compare_attributes.assert_called_once_with(source, target) mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_process_complex_extension_when_source_is_strict_type( self, mock_compare_attributes, mock_copy_attributes): mock_compare_attributes.return_value = ClassExtensionHandler.INCLUDES_NONE extension = ExtensionFactory.create() target = ClassFactory.create() source = ClassFactory.create(strict_type=True) self.processor.process_complex_extension(source, target, extension) mock_compare_attributes.assert_called_once_with(source, target) mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_copy_extensions(self): target = ClassFactory.create(extensions=ExtensionFactory.list(1)) source = ClassFactory.create(extensions=ExtensionFactory.list(2)) link_extension = ExtensionFactory.create() link_extension.restrictions.max_occurs = 2 ClassUtils.copy_extensions(source, target, link_extension) self.assertEqual(3, len(target.extensions)) self.assertEqual(2, target.extensions[1].restrictions.max_occurs) self.assertEqual(2, target.extensions[2].restrictions.max_occurs)
def test_process_complex_extension_when_target_has_suffix_attr( self, mock_compare_attributes, mock_copy_attributes): mock_compare_attributes.return_value = ClassExtensionHandler.INCLUDES_NONE extension = ExtensionFactory.create() target = ClassFactory.create() source = ClassFactory.create() target.attrs.append(AttrFactory.create(index=sys.maxsize)) self.processor.process_complex_extension(source, target, extension) mock_compare_attributes.assert_called_once_with(source, target) mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_find_attr_type(self, mock_find_class): target = ClassFactory.create() type_a = AttrTypeFactory.create() source = ClassFactory.create() mock_find_class.return_value = source actual = self.analyzer.find_attr_type(target, type_a) self.assertEqual(source, actual) mock_find_class.assert_called_once_with( source.source_qname(type_a.name))
def test_flatten_extension_complex_when_target_includes_no_source_attrs( self, mock_compare_attributes, mock_copy_attributes): mock_compare_attributes.return_value = self.analyzer.INCLUDES_NONE extension = ExtensionFactory.create() target = ClassFactory.create(extensions=[extension]) source = ClassFactory.create() self.analyzer.flatten_extension_complex(source, target, extension) mock_compare_attributes.assert_called_once_with(source, target) self.assertEqual(0, mock_copy_attributes.call_count) self.assertEqual(1, len(target.extensions))
def test_find_dependency(self): attr_type = AttrTypeFactory.create(qname="a") self.assertIsNone(self.processor.find_dependency(attr_type)) complex = ClassFactory.create(qname="a", type=ComplexType) self.processor.container.add(complex) self.assertEqual(complex, self.processor.find_dependency(attr_type)) simple = ClassFactory.create(qname="a", type=SimpleType) self.processor.container.add(simple) self.assertEqual(simple, self.processor.find_dependency(attr_type))
def test_flatten_extension_complex_when_source_depends_on_target( self, mock_compare_attributes, mock_class_depends_on_class, mock_copy_attributes ): mock_compare_attributes.return_value = self.analyzer.INCLUDES_SOME mock_class_depends_on_class.return_value = True extension = ExtensionFactory.create() target = ClassFactory.create() source = ClassFactory.create() self.analyzer.flatten_extension_complex(source, target, extension) mock_compare_attributes.assert_called_once_with(source, target) mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_flatten_extension_with_simple_source_extension( self, mock_find_class, mock_flatten_extension_simple ): extension = ExtensionFactory.create() target = ClassFactory.create(extensions=[extension]) source = ClassFactory.create() mock_find_class.return_value = source self.analyzer.flatten_extension(target, extension) type_qname = target.source_qname(extension.type.name) mock_find_class.assert_called_once_with(type_qname) mock_flatten_extension_simple.assert_called_once_with(source, target, extension)
def test_attr_depends_one(self, mock_find_class, mock_class_depends_on): target = ClassFactory.create() source = ClassFactory.create() attr_type = AttrTypeFactory.create() mock_find_class.side_effect = [None, target, source] mock_class_depends_on.return_value = True self.assertFalse(self.analyzer.attr_depends_on(attr_type, target)) self.assertTrue(self.analyzer.attr_depends_on(attr_type, target)) self.assertTrue(self.analyzer.attr_depends_on(attr_type, target)) mock_class_depends_on.assert_called_once_with(source, target)
def test_flatten_extension_complex_when_target_has_suffix_attr( self, mock_compare_attributes, mock_class_depends_on_class, mock_copy_attributes ): mock_compare_attributes.return_value = self.analyzer.INCLUDES_SOME mock_class_depends_on_class.return_value = False extension = ExtensionFactory.create() target = ClassFactory.create() source = ClassFactory.create() target.attrs.append(AttrFactory.create(index=sys.maxsize)) self.analyzer.flatten_extension_complex(source, target, extension) mock_compare_attributes.assert_called_once_with(source, target) mock_copy_attributes.assert_called_once_with(source, target, extension)