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_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_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_message_parts_with_original_message( self, mock_find_message, mock_create_message_attributes ): definitions = Definitions message_name = "foo:bar" ns_map = {} message = Message( name="session", parts=[ Part(name="token", element="foo:token"), Part(name="messageId", type="id"), Part(name="another", type="id"), ], ) extended = AnyElement() mock_create_message_attributes.return_value = AttrFactory.list(2) mock_find_message.return_value = message actual = DefinitionsMapper.map_binding_message_parts( definitions, message_name, extended, ns_map ) self.assertIsInstance(actual, Generator) self.assertEqual(2, len(list(actual))) mock_create_message_attributes.assert_called_once_with(message.parts, ns_map) mock_find_message.assert_called_once_with("bar")
def test_group_fields(self): target = ClassFactory.create(attrs=AttrFactory.list(2)) target.attrs[0].restrictions.min_occurs = 10 target.attrs[0].restrictions.max_occurs = 15 target.attrs[1].restrictions.min_occurs = 5 target.attrs[1].restrictions.max_occurs = 20 expected = AttrFactory.create( name="attr_B_Or_attr_C", tag="Choice", index=0, types=[AttrTypeFactory.xs_any()], choices=[ AttrFactory.create( tag=target.attrs[0].tag, name="attr_B", types=target.attrs[0].types, ), AttrFactory.create( tag=target.attrs[1].tag, name="attr_C", types=target.attrs[1].types, ), ], ) expected_res = Restrictions(min_occurs=5, max_occurs=20) self.sanitizer.group_fields(target, list(target.attrs)) self.assertEqual(1, len(target.attrs)) self.assertEqual(expected, target.attrs[0]) self.assertEqual(expected_res, target.attrs[0].restrictions)
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_process_attribute(self, mock_find): target = ClassFactory.create(attrs=[ AttrFactory.create(types=[AttrTypeFactory.create("foo")]), AttrFactory.create(types=[AttrTypeFactory.create("bar")]), ]) mock_find.side_effect = [-1, 2] first_attr = target.attrs[0] second_attr = target.attrs[1] first_attr.restrictions.max_occurs = 2 attr_qname = first_attr.types[0].qname reference_attrs = AttrFactory.list(2) self.processor.create_substitutions() self.processor.substitutions[attr_qname] = reference_attrs self.processor.process_attribute(target, first_attr) self.assertEqual(4, len(target.attrs)) self.assertEqual(reference_attrs[0], target.attrs[0]) self.assertIsNot(reference_attrs[0], target.attrs[0]) self.assertEqual(reference_attrs[1], target.attrs[3]) self.assertIsNot(reference_attrs[1], target.attrs[3]) self.assertEqual(2, target.attrs[0].restrictions.max_occurs) self.assertEqual(2, target.attrs[3].restrictions.max_occurs) self.processor.process_attribute(target, second_attr) self.assertEqual(4, len(target.attrs))
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_attribute(self, mock_find): target = ClassFactory.elements(2) mock_find.side_effect = [-1, 2] first_attr = target.attrs[0] second_attr = target.attrs[1] first_attr.restrictions.max_occurs = 2 attr_name = first_attr.name attr_qname = target.source_qname(attr_name) reference_attrs = AttrFactory.list(2) self.processor.create_substitutions() self.processor.substitutions[attr_qname] = reference_attrs self.processor.process_attribute(target, first_attr) self.assertEqual(4, len(target.attrs)) self.assertEqual(reference_attrs[0], target.attrs[0]) self.assertIsNot(reference_attrs[0], target.attrs[0]) self.assertEqual(reference_attrs[1], target.attrs[3]) self.assertIsNot(reference_attrs[1], target.attrs[3]) self.assertEqual(2, target.attrs[0].restrictions.max_occurs) self.assertEqual(2, target.attrs[3].restrictions.max_occurs) self.processor.process_attribute(target, second_attr) self.assertEqual(4, len(target.attrs))
def test_add_substitution_attrs(self, mock_find_attribute): target = ClassFactory.elements(2) mock_find_attribute.side_effect = [-1, 2] first_attr = target.attrs[0] second_attr = target.attrs[1] first_attr.restrictions.max_occurs = 2 attr_name = first_attr.name attr_qname = target.source_qname(attr_name) reference_attrs = AttrFactory.list(2) self.analyzer.substitutions_index[attr_qname] = reference_attrs self.analyzer.add_substitution_attrs(target, first_attr) self.assertEqual(4, len(target.attrs)) self.assertEqual(reference_attrs[0], target.attrs[0]) self.assertIsNot(reference_attrs[0], target.attrs[0]) self.assertEqual(reference_attrs[1], target.attrs[3]) self.assertIsNot(reference_attrs[1], target.attrs[3]) self.assertEqual(2, target.attrs[0].restrictions.max_occurs) self.assertEqual(2, target.attrs[3].restrictions.max_occurs) second_attr.wildcard = True self.analyzer.add_substitution_attrs(target, second_attr) self.assertEqual(4, len(target.attrs)) self.analyzer.add_substitution_attrs(target, AttrFactory.enumeration()) self.assertEqual(4, len(target.attrs))
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_field_metadata_choices(self): attr = AttrFactory.create(choices=AttrFactory.list(2, tag=Tag.ELEMENT)) actual = self.filters.field_metadata(attr, "foo", []) expected = [ {"name": "attr_B", "type": "Type[str]"}, {"name": "attr_C", "type": "Type[str]"}, ] self.assertEqual(expected, actual["choices"])
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_class( self, mock_class_name, mock_process_extension, mock_process_attributes, mock_process_enumerations, ): mock_class_name.side_effect = lambda x: f"@{x}" type_o = AttrTypeFactory.create(name="o") type_m = AttrTypeFactory.create(name="m") type_n = AttrTypeFactory.create(name="n") a = ClassFactory.create( name="a", extensions=[type_m, type_n], attrs=AttrFactory.list(2, local_type=TagType.EXTENSION), ) e = ClassFactory.enumeration(2, name="e") i = ClassFactory.create( name="i", extensions=[type_o], attrs=AttrFactory.list(2, local_type=TagType.EXTENSION), ) a.inner = [e, i] generator.process_class(a) mock_class_name.assert_has_calls( [mock.call("a"), mock.call("e"), mock.call("i")]) mock_process_extension.assert_has_calls( [mock.call(type_o), mock.call(type_m), mock.call(type_n)]) mock_process_attributes.assert_has_calls( [mock.call(i, ["@a", "@i"]), mock.call(a, ["@a"])]) mock_process_enumerations.assert_called_once_with(e)
def test_process_simple_dependency_with_more_than_one_attribute(self): source = ClassFactory.create(type=SimpleType, attrs=AttrFactory.list(2)) target = ClassFactory.elements(1) attr = target.attrs[0] attr_type = attr.types[0] with self.assertRaises(AnalyzerValueError) as cm: self.processor.process_simple_dependency(source, target, attr, attr_type) self.assertEqual("SimpleType with more than one attribute: `class_B`", str(cm.exception))
def test_flatten_attribute_types_when_source_has_more_than_one_attribute( self, mock_find_class, mock_logger_warning ): type_a = AttrTypeFactory.create(name="a") type_str = AttrTypeFactory.xs_string() common = ClassFactory.create(name="bar", attrs=AttrFactory.list(2)) mock_find_class.return_value = common parent = ClassFactory.create() attr = AttrFactory.create(name="a", types=[type_a]) self.analyzer.flatten_attribute_types(parent, attr) self.assertEqual([type_str], attr.types) mock_logger_warning.assert_called_once_with( "Missing type implementation: %s", common.type.__name__ )
def test_class_references(self): target = ClassFactory.elements( 2, inner=ClassFactory.list(2, attrs=AttrFactory.list(1)), extensions=ExtensionFactory.list(1), ) actual = ClassAnalyzer.class_references(target) # +1 target # +2 attrs # +2 attr types # +1 extension # +1 extension type # +2 inner classes # +2 inner classes attrs # +2 inner classes attr types self.assertEqual(13, len(actual)) self.assertEqual(id(target), actual[0])
def test_compare_attributes(self): source = ClassFactory.elements(2) self.assertEqual(2, ClassUtils.compare_attributes(source, source)) target = ClassFactory.create() self.assertEqual(0, ClassUtils.compare_attributes(source, target)) target.attrs = [attr.clone() for attr in source.attrs] self.assertEqual(2, ClassUtils.compare_attributes(source, target)) source.attrs.append(AttrFactory.element()) self.assertEqual(1, ClassUtils.compare_attributes(source, target)) source.attrs = AttrFactory.list(3) self.assertEqual(0, ClassUtils.compare_attributes(source, target)) self.assertEqual(0, ClassUtils.INCLUDES_NONE) self.assertEqual(1, ClassUtils.INCLUDES_SOME) self.assertEqual(2, ClassUtils.INCLUDES_ALL)
def test_build_message_class(self, mock_create_message_attributes): message = Message(name="bar", parts=[Part()]) message.ns_map["foo"] = "bar" definitions = Definitions( messages=[message], target_namespace="xsdata", location="foo.wsdl" ) port_type_message = PortTypeMessage(message="foo:bar") attrs = AttrFactory.list(2) mock_create_message_attributes.return_value = attrs actual = DefinitionsMapper.build_message_class(definitions, port_type_message) expected = Class( qname=build_qname("xsdata", "bar"), status=Status.PROCESSED, type=Element, module="foo", ns_map=message.ns_map, attrs=attrs, ) self.assertEqual(expected, actual)
def test_create_substitutions(self, mock_create_substitution): 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_substitution.side_effect = reference_attrs self.processor.container.extend(classes) self.processor.create_substitutions() expected = { QName(namespace, "foo"): [reference_attrs[0], reference_attrs[2]], QName(namespace, "bar"): [reference_attrs[1]], } self.assertEqual(expected, self.processor.substitutions) mock_create_substitution.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 mock_create_attr(*args, **kwargs): return AttrFactory.list(1)