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_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( 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_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_merge_redefined_type_with_circular_extension( self, mock_copy_attributes, mock_copy_extensions ): source = ClassFactory.create() target = source.clone() ext_a = ExtensionFactory.create(type=AttrTypeFactory.create(qname=source.name)) ext_str = ExtensionFactory.create(type=AttrTypeFactory.create(qname="foo")) target.extensions.append(ext_str) target.extensions.append(ext_a) self.validator.merge_redefined_type(source, target) mock_copy_attributes.assert_called_once_with(source, target, ext_a) mock_copy_extensions.assert_called_once_with(source, target, ext_a)
def test_merge_redefined_classes_copies_attributes(self, mock_copy_attributes): class_a = ClassFactory.create() class_b = ClassFactory.create() class_c = class_a.clone() ext_a = ExtensionFactory.create(type=AttrTypeFactory.create(name=class_a.name)) ext_str = ExtensionFactory.create(type=AttrTypeFactory.create(name="foo")) class_c.extensions.append(ext_a) class_c.extensions.append(ext_str) classes = [class_a, class_b, class_c] self.analyzer.merge_redefined_classes(classes) self.assertEqual(2, len(classes)) mock_copy_attributes.assert_called_once_with(class_a, class_c, ext_a)
def test_remove_invalid_classes(self): first = ClassFactory.create(extensions=[ ExtensionFactory.create(type=AttrTypeFactory.xs_bool()), ExtensionFactory.create(type=AttrTypeFactory.create(name="foo")), ]) second = ClassFactory.create(extensions=[ ExtensionFactory.create(type=AttrTypeFactory.xs_bool()), ]) third = ClassFactory.create() self.validator.container.extend([first, second, third]) classes = [first, second, third] self.validator.remove_invalid_classes(classes) self.assertEqual([second, third], classes)
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_process_native_extension_with_enumeration_target( self, mock_copy_extension_type): extension = ExtensionFactory.create() target = ClassFactory.enumeration(1) self.processor.process_native_extension(target, extension) mock_copy_extension_type.assert_called_once_with(target, extension)
def test_process_extension_native(self, mock_create_default_attribute): extension = ExtensionFactory.create() target = ClassFactory.elements(1) self.processor.process_native_extension(target, extension) mock_create_default_attribute.assert_called_once_with( target, extension)
def test_create_default_attribute_with_any_type(self): extension = ExtensionFactory.create( type=AttrTypeFactory.xs_any(), restrictions=Restrictions(min_occurs=1, max_occurs=1, required=True), ) item = ClassFactory.create(extensions=[extension]) ClassExtensionHandler.create_default_attribute(item, extension) expected = AttrFactory.create( name="any_element", index=0, default=None, types=[extension.type.clone()], tag=Tag.ANY, namespace="##any", restrictions=Restrictions(min_occurs=1, max_occurs=1, required=True), ) self.assertEqual(1, len(item.attrs)) self.assertEqual(0, len(item.extensions)) self.assertEqual(expected, item.attrs[0])
def test_flatten_extension_native_and_target_enumeration( self, mock_create_default_attribute): extension = ExtensionFactory.create() target = ClassFactory.enumeration(1) self.analyzer.flatten_extension_native(target, extension) self.assertEqual(0, mock_create_default_attribute.call_count)
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_flatten_extension_simple_when_source_and_target_are_not_enumerations( self, mock_copy_attributes): source = ClassFactory.elements(2) target = ClassFactory.elements(1) extension = ExtensionFactory.create() self.analyzer.flatten_extension_simple(source, target, extension) mock_copy_attributes.assert_called_once_with(source, target, extension)
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_extension_with_dependency_type( self, mock_process_dependency_extension): extension = ExtensionFactory.create(type=AttrTypeFactory.create("foo")) target = ClassFactory.elements(1, extensions=[extension]) self.processor.process_extension(target, extension) mock_process_dependency_extension.assert_called_once_with( target, extension)
def test_flatten_extension_native_and_target_no_enumeration( self, mock_create_default_attribute): extension = ExtensionFactory.create() target = ClassFactory.elements(1) self.analyzer.flatten_extension_native(target, extension) mock_create_default_attribute.assert_called_once_with( target, extension)
def test_flatten_extension_with_native_type(self, mock_flatten_extension_native): extension = ExtensionFactory.create(type=AttrTypeFactory.xs_string()) target = ClassFactory.elements(1, extensions=[extension]) self.analyzer.flatten_extension(target, extension) mock_flatten_extension_native.assert_called_once_with( target, extension)
def test_process_extension(self, mock_type_name): extension = ExtensionFactory.create(type=AttrTypeFactory.create( name="foobar")) generator.process_extension(extension) mock_type_name.assert_called_once_with(extension.type) self.assertEqual("oof", extension.type.name)
def test_flatten_extension_with_native_type_and_target_not_enumeration( self, mock_create_default_attribute ): extension = ExtensionFactory.create(type=AttrTypeFactory.xs_string()) target = ClassFactory.elements(1, extensions=[extension]) self.analyzer.flatten_extension(target, extension) mock_create_default_attribute.assert_called_once_with(target, extension)
def test_flatten_extension_with_unknown_extension_type( self, mock_logger_warning): extension = ExtensionFactory.create() target = ClassFactory.create(extensions=[extension]) self.analyzer.flatten_extension(target, extension) self.assertEqual(0, len(target.extensions)) mock_logger_warning.assert_called_once_with( "Missing extension type: %s", extension.type.name)
def test_flatten_extension_simple_when_source_is_enumeration_and_target_is_not( self, mock_create_default_attribute ): source = ClassFactory.enumeration(2) target = ClassFactory.elements(1) extension = ExtensionFactory.create() self.analyzer.flatten_extension_simple(source, target, extension) mock_create_default_attribute.assert_called_once_with(target, extension)
def test_flatten_extension_simple_when_target_is_enumeration_and_source_is_not( self, mock_create_default_attribute, mock_copy_attributes): extension = ExtensionFactory.create() source = ClassFactory.elements(2) target = ClassFactory.enumeration(1, extensions=[extension]) self.analyzer.flatten_extension_simple(source, target, extension) self.assertEqual(0, mock_create_default_attribute.call_count) self.assertEqual(0, mock_copy_attributes.call_count) self.assertEqual(0, len(target.extensions))
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_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_extension_type(self): extension = ExtensionFactory.create() target = ClassFactory.elements(2) target.extensions.append(extension) ClassExtensionHandler.copy_extension_type(target, extension) self.assertEqual(extension.type, target.attrs[0].types[1]) self.assertEqual(extension.type, target.attrs[1].types[1]) self.assertEqual(0, len(target.extensions))
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_build_class_extensions(self, mock_children_extensions): bar_type = AttrTypeFactory.create(qname="bar") foo_type = AttrTypeFactory.create(qname="foo") some_type = AttrTypeFactory.create(qname="{xsdata}something") bar = ExtensionFactory.create(type=bar_type) double = ExtensionFactory.create(type=bar_type) foo = ExtensionFactory.create(type=foo_type) mock_children_extensions.return_value = [bar, double, foo] self_ext = ExtensionFactory.create(type=some_type, restrictions=Restrictions( min_occurs=1, max_occurs=1)) item = ClassFactory.create() element = Element(type="something") SchemaMapper.build_class_extensions(element, item) self.assertEqual(3, len(item.extensions)) self.assertCountEqual([bar, self_ext, foo], item.extensions)
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_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))