def test_root_elements(self):
override = Override()
redefine = Redefine()
redefine.annotation = Annotation()
redefine.complex_types.append(ComplexType())
override.annotation = Annotation()
override.groups.append(Group())
override.simple_types.append(SimpleType())
schema = Schema()
schema.simple_types.append(SimpleType())
schema.attribute_groups.append(AttributeGroup())
schema.groups.append(Group())
schema.attributes.append(Attribute())
schema.complex_types.append(ComplexType())
schema.elements.append(Element())
schema.redefines.append(redefine)
schema.overrides.append(override)
iterator = SchemaMapper.root_elements(schema)
expected = [
("Override", override.simple_types[0]),
("Override", override.groups[0]),
("Redefine", redefine.complex_types[0]),
("Schema", schema.simple_types[0]),
("Schema", schema.complex_types[0]),
("Schema", schema.groups[0]),
("Schema", schema.attribute_groups[0]),
("Schema", schema.elements[0]),
("Schema", schema.attributes[0]),
]
self.assertEqual(expected, list(iterator))
def test_end_complex_type(self):
complex_type = ComplexType()
not_complex_type = Element()
element = etree.Element("uno")
self.parser.end_complex_type(not_complex_type, element)
self.parser.end_complex_type(complex_type, element)
self.assertEqual(0, len(complex_type.attribute_groups))
self.assertIsNone(complex_type.open_content)
self.parser.default_attributes = "tns:attrs"
self.parser.end_complex_type(complex_type, element)
expected = AttributeGroup(ref="tns:attrs")
self.assertEqual([expected], complex_type.attribute_groups)
self.assertIsNone(complex_type.open_content)
default_open_content = DefaultOpenContent()
self.parser.default_attributes = None
self.parser.default_open_content = default_open_content
self.parser.end_complex_type(complex_type, element)
self.assertIs(default_open_content, complex_type.open_content)
open_content = OpenContent()
complex_type.open_content = open_content
self.parser.end_complex_type(complex_type, element)
self.assertIs(open_content, complex_type.open_content)
def test_property_is_mixed(self):
obj = ComplexType()
self.assertFalse(obj.is_mixed)
obj.complex_content = ComplexContent()
self.assertFalse(obj.is_mixed)
obj.complex_content.mixed = True
self.assertTrue(obj.is_mixed)
obj.complex_content.mixed = False
obj.mixed = True
self.assertTrue(obj.is_mixed)
def test_element_children(self):
sequence_one = Sequence(elements=[Element(), Element()])
sequence_two = Sequence(max_occurs=2, elements=[Element(), Element()])
restriction = Restriction(
enumerations=[Enumeration(value=x) for x in "abc"], sequence=sequence_two,
)
complex_type = ComplexType(
attributes=[Attribute(), Attribute()],
sequence=sequence_one,
simple_content=SimpleContent(restriction=Restriction()),
complex_content=ComplexContent(restriction=restriction,),
)
restrictions = Restrictions.from_element(complex_type)
children = self.builder.element_children(complex_type, restrictions)
expected = [
(sequence_two.elements[0], Restrictions.from_element(sequence_two)),
(sequence_two.elements[1], Restrictions.from_element(sequence_two)),
(restriction.enumerations[0], Restrictions.from_element(restriction)),
(restriction.enumerations[1], Restrictions.from_element(restriction)),
(restriction.enumerations[2], Restrictions.from_element(restriction)),
(sequence_one.elements[0], Restrictions.from_element(sequence_one)),
(sequence_one.elements[1], Restrictions.from_element(sequence_one)),
(complex_type.attributes[0], Restrictions.from_element(complex_type)),
(complex_type.attributes[1], Restrictions.from_element(complex_type)),
]
self.assertIsInstance(children, GeneratorType)
self.assertEqual(expected, list(children))
def test_end_schema(
self,
mock_set_schema_forms,
mock_set_schema_namespaces,
mock_add_default_imports,
mock_resolve_schemas_locations,
):
schema = Schema()
schema.elements.append(Element())
schema.elements.append(Element())
schema.elements.append(Element())
for el in schema.elements:
self.assertEqual(1, el.min_occurs)
self.assertEqual(1, el.max_occurs)
self.parser.end_schema(schema)
for el in schema.elements:
self.assertIsNone(el.min_occurs)
self.assertIsNone(el.max_occurs)
self.parser.end_schema(ComplexType())
mock_set_schema_forms.assert_called_once_with(schema)
mock_set_schema_namespaces.assert_called_once_with(schema)
mock_add_default_imports.assert_called_once_with(schema)
mock_resolve_schemas_locations.assert_called_once_with(schema)
def test_build_inner_classes(self, mock_build_class):
inner_classes = ClassFactory.list(2)
mock_build_class.side_effect = inner_classes
simple_type = SimpleType()
complex_type = ComplexType()
enumeration = SimpleType(restriction=Restriction(
enumerations=[Enumeration(value="a")]))
element = Element(alternatives=[
Alternative(complex_type=complex_type, id="a"),
Alternative(simple_type=simple_type, id="b"),
Alternative(simple_type=enumeration, id="c"),
])
result = SchemaMapper.build_inner_classes(element, "module",
"target_ns")
self.assertIsInstance(result, Iterator)
self.assertEqual(inner_classes, list(result))
self.assertEqual("a", complex_type.name)
self.assertEqual("c", enumeration.name)
mock_build_class.assert_has_calls([
mock.call(complex_type, Tag.ALTERNATIVE, "module", "target_ns"),
mock.call(enumeration, Tag.ALTERNATIVE, "module", "target_ns"),
])
def test_children(self):
one = SimpleType(id="1")
two = ComplexType(id="10")
three = Alternative(id="11")
four = Alternative(id="12")
element = Element(
name="super",
complex_type=two,
simple_type=one,
alternatives=[three, four],
)
children = element.children()
self.assertIsInstance(children, Generator)
self.assertEqual([one, two, three, four], list(children))
children = list(element.children(lambda x: x.id == "10"))
self.assertEqual([two], children)
children = list(element.children(lambda x: x.id == "12"))
self.assertEqual([four], children)
children = list(element.children(lambda x: int(x.id) % 2 == 0))
self.assertEqual([two, four], children)
def test_map(self, mock_root_elements, mock_build_class):
simple_type = ComplexType()
complex_type = ComplexType()
schema = Schema(target_namespace="fooNS", location="foo.xsd")
mock_build_class.side_effect = ClassFactory.list(3)
mock_root_elements.return_value = [
(Tag.SCHEMA, Group),
(Tag.OVERRIDE, simple_type),
(Tag.REDEFINE, complex_type),
]
actual = SchemaMapper.map(schema)
self.assertEqual(3, len(actual))
self.assertIsInstance(actual[0], Class)
mock_root_elements.assert_called_once_with(schema)
def test_property_has_children(self):
element = ElementBase()
self.assertFalse(element.has_children)
element = Element()
self.assertFalse(element.has_children)
element.complex_type = ComplexType()
self.assertTrue(element.has_children)
def test_property_is_mixed(self):
obj = Element()
self.assertFalse(obj.is_mixed)
obj.complex_type = ComplexType()
self.assertFalse(obj.is_mixed)
obj.complex_type.mixed = True
self.assertTrue(obj.is_mixed)
def test_property_raw_type(self):
obj = Element(ns_map={"xs": Namespace.XS.uri})
self.assertEqual("xs:anyType", obj.raw_type)
obj.type = "foo"
self.assertEqual("foo", obj.raw_type)
obj.type = None
obj.complex_type = ComplexType()
self.assertIsNone(obj.raw_type)
def test_property_bases(self):
obj = Element()
obj.ns_map["xs"] = Namespace.XS.uri
self.assertEqual(["xs:anyType"], list(obj.bases))
obj.type = "foo"
self.assertEqual(["foo"], list(obj.bases))
obj.type = None
obj.complex_type = ComplexType()
self.assertEqual([], list(obj.bases))
def test_element_children_with_parents_restrictions(self):
choice = Choice(elements=[Element(name="elem1")])
complex_type = ComplexType(
sequence=Sequence(choices=[choice], min_occurs=0, max_occurs=3))
parent_restrictions = Restrictions.from_element(complex_type)
children = SchemaMapper.element_children(complex_type,
parent_restrictions)
child, restrictions = next(children)
expected = Restrictions(min_occurs=0,
max_occurs=3,
sequential=True,
choice=str(id(choice)))
self.assertEqual(expected, restrictions)
def test_end_default_open_content(self):
default_open_content = DefaultOpenContent()
default_open_content.any = Any()
self.parser.end_default_open_content(default_open_content)
self.assertEqual(default_open_content, self.parser.default_open_content)
self.assertEqual(0, default_open_content.any.index)
default_open_content.mode = Mode.SUFFIX
self.parser.end_default_open_content(default_open_content)
self.assertEqual(sys.maxsize, default_open_content.any.index)
obj = ComplexType()
self.parser.end_default_open_content(obj)
self.assertIsNone(obj.open_content)
def test_build(self, mock_build_class):
schema = self.schema
override = Override()
redefine = Redefine()
redefine.annotation = Annotation()
redefine.complex_types.append(ComplexType())
override.annotation = Annotation()
override.groups.append(Group())
override.simple_types.append(SimpleType())
schema.simple_types.append(SimpleType())
schema.attribute_groups.append(AttributeGroup())
schema.groups.append(Group())
schema.attributes.append(Attribute())
schema.complex_types.append(ComplexType())
schema.elements.append(Element())
schema.redefines.append(redefine)
schema.overrides.append(override)
self.builder.build()
mock_build_class.assert_has_calls(
[
mock.call(override.simple_types[0], container=override.class_name),
mock.call(override.groups[0], container=override.class_name),
mock.call(redefine.complex_types[0], container=redefine.class_name),
mock.call(schema.simple_types[0], container=schema.class_name),
mock.call(schema.complex_types[0], container=schema.class_name),
mock.call(schema.groups[0], container=schema.class_name),
mock.call(schema.attribute_groups[0], container=schema.class_name),
mock.call(schema.elements[0], container=schema.class_name),
mock.call(schema.attributes[0], container=schema.class_name),
]
)
def test_end_extension(self):
extension = Extension()
not_extension = Element()
self.parser.end_extension(not_extension)
self.parser.end_extension(extension)
default_open_content = DefaultOpenContent()
self.parser.default_open_content = default_open_content
self.parser.end_extension(extension)
self.assertIs(default_open_content, extension.open_content)
open_content = OpenContent()
extension.open_content = open_content
self.parser.end_extension(extension)
self.assertIs(open_content, extension.open_content)
obj = ComplexType()
self.parser.end_extension(obj)
self.assertIsNone(obj.open_content)
def test_end_restriction(self):
restriction = Restriction()
not_restriction = Element()
self.parser.end_restriction(not_restriction)
self.parser.end_restriction(restriction)
default_open_content = DefaultOpenContent()
self.parser.default_open_content = default_open_content
self.parser.end_restriction(restriction)
self.assertIs(default_open_content, restriction.open_content)
open_content = OpenContent()
restriction.open_content = open_content
self.parser.end_restriction(restriction)
self.assertIs(open_content, restriction.open_content)
obj = ComplexType()
self.parser.end_open_content(obj)
self.assertIsNone(obj.open_content)
def test_children_extensions(self):
complex_type = ComplexType(
attributes=[Attribute(index=i) for i in range(2)],
simple_content=SimpleContent(restriction=Restriction(base="bk:b", index=4)),
complex_content=ComplexContent(extension=Extension(base="bk:ext", index=7)),
)
item = ClassFactory.create()
children = self.builder.children_extensions(complex_type, item)
expected = list(
map(
ExtensionFactory.create,
[
AttrTypeFactory.create(name="bk:b", index=4),
AttrTypeFactory.create(name="bk:ext", index=7),
],
)
)
self.assertIsInstance(children, GeneratorType)
self.assertEqual(expected, list(children))
def test_property_attr_types(self):
obj = Element()
self.assertEqual([], list(obj.attr_types))
# Inner classes depend on the this to be None
obj.complex_type = ComplexType()
self.assertEqual([], list(obj.attr_types))
restriction = Restriction(base="xs:int")
obj.simple_type = SimpleType(restriction=restriction)
self.assertEqual([restriction.base], list(obj.attr_types))
obj.ref = "foo"
self.assertEqual([obj.ref], list(obj.attr_types))
obj.type = "bar"
self.assertEqual([obj.type], list(obj.attr_types))
obj.alternatives.append(Alternative(type="foo"))
obj.alternatives.append(Alternative(type="bar"))
obj.alternatives.append(Alternative(type="thug"))
self.assertEqual(["bar", "foo", "bar", "thug"], list(obj.attr_types))
def test_children_extensions(self):
complex_type = ComplexType(
attributes=[Attribute() for _ in range(2)],
simple_content=SimpleContent(restriction=Restriction(base="bk:b")),
complex_content=ComplexContent(extension=Extension(base="bk:c")),
)
complex_type.simple_content.restriction.index = 4
complex_type.complex_content.extension.index = 7
item = ClassFactory.create(ns_map={"bk": "book"})
children = SchemaMapper.children_extensions(complex_type, item)
expected = list(
map(
ExtensionFactory.create,
[
AttrTypeFactory.create(qname=build_qname("book", "b")),
AttrTypeFactory.create(qname=build_qname("book", "c")),
],
))
self.assertIsInstance(children, GeneratorType)
self.assertEqual(expected, list(children))
def test_property_real_type(self):
obj = Element()
self.assertEqual("", obj.real_type)
# Inner classes depend on the this to be None
obj.complex_type = ComplexType()
self.assertEqual("", obj.real_type)
restriction = Restriction(base="xs:int")
obj.simple_type = SimpleType(restriction=restriction)
self.assertEqual(restriction.base, obj.real_type)
obj.ref = "foo"
self.assertEqual(obj.ref, obj.real_type)
obj.type = "bar"
self.assertEqual(obj.type, obj.real_type)
obj.alternatives.append(Alternative(type="foo"))
obj.alternatives.append(Alternative(type="bar"))
obj.alternatives.append(Alternative(type="thug"))
self.assertEqual("bar foo thug", obj.real_type)
def test_property_extensions(self):
obj = ComplexType()
self.assertEqual([], list(obj.extensions))
