def test_attribute_type_with_forwarderence(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(1, name="foo_bar", forward=True)
)
self.assertEqual(
'Optional["Parent.Inner.FooBar"]', attribute_type(attr, ["Parent", "Inner"])
)
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_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_field_type_with_forward_reference(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(1, qname="foo_bar", forward=True)
)
self.assertEqual(
'Optional["Parent.Inner.FooBar"]',
self.filters.field_type(attr, ["Parent", "Inner"]),
)
def test_attribute_default_with_type_enum(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(1, name="foo"), default="@enum@foo::bar"
)
self.assertEqual("Foo.BAR", attribute_default(attr))
attr.types[0].alias = "foo_bar"
self.assertEqual("FooBar.BAR", attribute_default(attr))
def test_attribute_type_with_list_type(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(1, name="foo_bar", forward=True)
)
attr.restrictions.max_occurs = 2
self.assertEqual(
'List["A.Parent.FooBar"]', attribute_type(attr, ["A", "Parent"])
)
def test_field_type_with_circular_reference(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(1, qname="foo_bar", circular=True)
)
self.assertEqual(
'Optional["FooBar"]', self.filters.field_type(attr, ["Parent"])
)
def test_field_type_with_token_attr(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(1, qname="foo_bar"),
restrictions=Restrictions(tokens=True),
)
self.assertEqual("List[FooBar]", self.filters.field_type(attr, []))
attr.restrictions.max_occurs = 2
self.assertEqual("List[List[FooBar]]", self.filters.field_type(attr, []))
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_field_type_with_alias(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(
1, qname="foo_bar", forward=True, alias="Boss:Life"
)
)
attr.restrictions.max_occurs = 2
self.assertEqual(
'List["A.Parent.BossLife"]',
self.filters.field_type(attr, ["A", "Parent"]),
)
def test_field_default_value_with_type_enum(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(1, qname="foo"), default="@enum@foo::bar"
)
self.assertEqual("Foo.BAR", self.filters.field_default_value(attr))
attr.types[0].alias = "foo_bar"
self.assertEqual("FooBar.BAR", self.filters.field_default_value(attr))
attr.types[0].qname = "nomatch" # impossible
with self.assertRaises(Exception):
self.filters.field_default_value(attr)
def test_build_class_attribute(
self,
mock_real_name,
mock_display_help,
mock_prefix,
mock_default_value,
mock_is_fixed,
mock_is_wildcard,
mock_get_restrictions,
mock_element_namespace,
mock_build_class_attribute_types,
):
item = ClassFactory.create(ns_map={"bar": "foo"})
mock_build_class_attribute_types.return_value = AttrTypeFactory.list(
1, name="xs:int")
mock_real_name.return_value = item.name
mock_display_help.return_value = "sos"
mock_prefix.return_value = "com"
mock_default_value.return_value = "default"
mock_is_fixed.return_value = True
mock_is_wildcard.return_value = True
mock_element_namespace.return_value = "http://something/common"
mock_get_restrictions.return_value = {"required": True}
attribute = Attribute.create(default="false",
index=66,
ns_map={"foo": "bar"})
self.builder.build_class_attribute(item, attribute, Restrictions())
expected = AttrFactory.create(
name=mock_real_name.return_value,
types=mock_build_class_attribute_types.return_value,
local_type=Attribute.__name__,
namespace=mock_element_namespace.return_value,
help=mock_display_help.return_value,
default=mock_default_value.return_value,
fixed=mock_is_fixed.return_value,
wildcard=mock_is_wildcard.return_value,
index=66,
restrictions=Restrictions(required=True),
)
self.assertEqual(expected, item.attrs[0])
self.assertEqual({"bar": "foo", "foo": "bar"}, item.ns_map)
mock_build_class_attribute_types.assert_called_once_with(
item, attribute)
mock_element_namespace.assert_called_once_with(attribute)
def test_attribute_type_with_optional_value(self):
attr = AttrFactory.create(types=AttrTypeFactory.list(1, name="foo_bar"))
self.assertEqual("Optional[FooBar]", attribute_type(attr, []))
def test_attribute_type_with_default_value(self):
attr = AttrFactory.create(
default="foo", types=AttrTypeFactory.list(1, name="foo_bar")
)
self.assertEqual("FooBar", attribute_type(attr, []))
def test_field_type_with_optional_value(self):
attr = AttrFactory.create(types=AttrTypeFactory.list(1, qname="foo_bar"))
self.assertEqual("Optional[FooBar]", self.filters.field_type(attr, []))
def test_field_type_with_default_value(self):
attr = AttrFactory.create(
default="foo", types=AttrTypeFactory.list(1, qname="foo_bar")
)
self.assertEqual("FooBar", self.filters.field_type(attr, []))
def test_attribute_type_with_circularerence(self):
attr = AttrFactory.create(
types=AttrTypeFactory.list(1, name="foo_bar", circular=True)
)
self.assertEqual('Optional["FooBar"]', attribute_type(attr, ["Parent"]))