def test_element_children(self):
sequence_one = Sequence.create(elements=[Element.create(), Element.create()])
sequence_two = Sequence.create(
max_occurs=2, elements=[Element.create(), Element.create()]
)
restriction = Restriction.create(
enumerations=[Enumeration.create(value=x) for x in "abc"],
sequence=sequence_two,
)
complex_type = ComplexType.create(
attributes=[Attribute.create(), Attribute.create()],
sequence=sequence_one,
simple_content=SimpleContent.create(restriction=Restriction.create()),
complex_content=ComplexContent.create(restriction=restriction,),
)
children = self.builder.element_children(complex_type)
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_property_real_name(self):
obj = Element.create(ref="bar")
self.assertEqual("bar", obj.real_name)
obj.name = "foo"
self.assertEqual("foo", obj.real_name)
with self.assertRaises(SchemaValueError):
obj = Element.create()
obj.real_name
def test_build(
self, mock_build_class, mock_override_children, mock_redefine_children
):
for _ in range(2):
self.schema.simple_types.append(SimpleType.create())
self.schema.attribute_groups.append(AttributeGroup.create())
self.schema.groups.append(Group.create())
self.schema.attributes.append(Attribute.create())
self.schema.complex_types.append(ComplexType.create())
self.schema.elements.append(Element.create())
self.schema.redefines.append(Redefine.create())
self.schema.overrides.append(Override.create())
override_element = Element.create()
override_attribute = Attribute.create()
override_complex_type = ComplexType.create()
redefine_simple_type = SimpleType.create()
redefine_group = Group.create()
redefine_attribute_group = AttributeGroup.create()
mock_redefine_children.side_effect = [
[redefine_simple_type, redefine_group],
[redefine_attribute_group],
]
mock_override_children.side_effect = [
[override_element, override_attribute],
[override_complex_type],
]
mock_build_class.side_effect = classes = ClassFactory.list(18)
self.assertEqual(classes, self.builder.build())
mock_build_class.assert_has_calls(
[
mock.call(override_element),
mock.call(override_attribute),
mock.call(override_complex_type),
mock.call(redefine_simple_type),
mock.call(redefine_group),
mock.call(redefine_attribute_group),
mock.call(self.schema.simple_types[0]),
mock.call(self.schema.simple_types[1]),
mock.call(self.schema.attribute_groups[0]),
mock.call(self.schema.attribute_groups[1]),
mock.call(self.schema.groups[0]),
mock.call(self.schema.groups[1]),
mock.call(self.schema.attributes[0]),
mock.call(self.schema.attributes[1]),
mock.call(self.schema.complex_types[0]),
mock.call(self.schema.complex_types[1]),
mock.call(self.schema.elements[0]),
mock.call(self.schema.elements[1]),
]
)
def test_has_anonymous_class(self):
obj = Element.create()
self.assertFalse(self.builder.has_anonymous_class(obj))
obj = Element.create(type="foo")
self.assertFalse(self.builder.has_anonymous_class(obj))
obj = Element.create(complex_type=ComplexType.create())
self.assertTrue(self.builder.has_anonymous_class(obj))
obj = Attribute.create()
self.assertFalse(self.builder.has_anonymous_class(obj))
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.create(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_build_inner_classes(self, mock_build_class):
inner_classes = ClassFactory.list(2)
mock_build_class.side_effect = inner_classes
simple_type = SimpleType.create()
complex_type = ComplexType.create()
enumeration = SimpleType.create(
restriction=Restriction.create(enumerations=[Enumeration.create(value="a")])
)
element = Element.create(
alternatives=[
Alternative.create(complex_type=complex_type, id="a"),
Alternative.create(simple_type=simple_type, id="b"),
Alternative.create(simple_type=enumeration, id="c"),
]
)
result = self.builder.build_inner_classes(element)
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), mock.call(enumeration)]
)
def test_set_schema_forms_default(self):
schema = Schema()
schema.elements.append(Element.create())
schema.elements.append(Element.create())
schema.attributes.append(Element.create())
schema.attributes.append(Element.create())
self.parser.set_schema_forms(schema)
self.assertEqual(FormType.UNQUALIFIED, schema.element_form_default)
self.assertEqual(FormType.UNQUALIFIED, schema.attribute_form_default)
for child_element in schema.elements:
self.assertEqual(FormType.QUALIFIED, child_element.form)
for child_attribute in schema.attributes:
self.assertEqual(FormType.QUALIFIED, child_attribute.form)
def test_property_has_children(self):
element = ElementBase()
self.assertFalse(element.has_children)
element = Element.create()
self.assertFalse(element.has_children)
element.complex_type = ComplexType.create()
self.assertTrue(element.has_children)
def test_property_is_mixed(self):
obj = Element.create()
self.assertFalse(obj.is_mixed)
obj.complex_type = ComplexType.create()
self.assertFalse(obj.is_mixed)
obj.complex_type.mixed = True
self.assertTrue(obj.is_mixed)
def test_end_Element(self):
obj = Element()
element = etree.Element("uno")
self.parser.end_element(obj, element)
self.assertIsNone(obj.form)
self.parser.element_form = "qualified"
self.parser.end_element(obj, element)
self.assertEqual(FormType.QUALIFIED, obj.form)
def test_property_raw_type(self):
obj = Element.create()
self.assertEqual("xs:anyType", obj.raw_type)
obj.type = "foo"
self.assertEqual("foo", obj.raw_type)
obj.type = None
obj.complex_type = ComplexType.create()
self.assertIsNone(obj.raw_type)
def test_build_inner_class_when_has_anonymous_class(
self, mock_has_anonymous_class, mock_build_class):
inner_class = ClassFactory.create()
mock_build_class.return_value = inner_class
mock_has_anonymous_class.return_value = True
complex_type = ComplexType.create()
element = Element.create(name="foo", complex_type=complex_type)
self.assertEqual(inner_class, self.builder.build_inner_class(element))
self.assertIsNone(element.complex_type)
self.assertEqual("foo", complex_type.name)
def test_element_namespace(self):
self.schema.target_namespace = "foobar"
element = Element.create(ref="foo:something")
element.ns_map["foo"] = "bar"
self.assertEqual("bar", self.builder.element_namespace(element))
element = Element.create(form=FormType.QUALIFIED)
self.assertEqual("foobar", self.builder.element_namespace(element))
element = Element.create()
self.assertEqual("", self.builder.element_namespace(element))
element.target_namespace = "tns"
self.assertEqual("tns", self.builder.element_namespace(element))
attribute = Attribute.create()
self.assertIsNone(self.builder.element_namespace(attribute))
attribute.target_namespace = "tns"
self.assertEqual("tns", self.builder.element_namespace(attribute))
def test_end_schema(
self,
mock_set_schema_forms,
mock_set_schema_namespaces,
mock_add_default_imports,
mock_resolve_schemas_locations,
):
schema = Schema.create()
element = Element("schema")
self.parser.end_schema(schema, element)
mock_set_schema_forms.assert_called_once_with(schema)
mock_set_schema_namespaces.assert_called_once_with(schema, element)
mock_add_default_imports.assert_called_once_with(schema)
mock_resolve_schemas_locations.assert_called_once_with(schema)
def test_build_inner_class_when_has_anonymous_enumeration(
self, mock_has_anonymous_class, mock_has_anonymous_enumeration,
mock_build_class):
inner_class = ClassFactory.create()
mock_build_class.return_value = inner_class
mock_has_anonymous_class.return_value = False
mock_has_anonymous_enumeration.return_value = True
simple_type = SimpleType.create()
element = Element.create(name="foo",
simple_type=simple_type,
type="xs:int")
self.assertEqual(inner_class, self.builder.build_inner_class(element))
self.assertIsNone(element.simple_type)
self.assertIsNone(element.type)
self.assertEqual("foo", simple_type.name)
def test_get_restrictions(self):
obj = Element.create(min_occurs=1, max_occurs=1)
expected = {"min_occurs": 1, "max_occurs": 1}
self.assertEqual(expected, obj.get_restrictions())
obj.simple_type = SimpleType.create(
restriction=Restriction.create(length=Length.create(value=9))
)
expected.update({"length": 9})
self.assertEqual(expected, obj.get_restrictions())
obj.nillable = False
self.assertEqual(expected, obj.get_restrictions())
obj.nillable = True
expected.update({"nillable": True})
self.assertEqual(expected, obj.get_restrictions())
def test_end_extension(self):
extension = Extension()
not_extension = Element()
element = etree.Element("uno")
self.parser.end_extension(not_extension, element)
self.parser.end_extension(extension, element)
default_open_content = DefaultOpenContent()
self.parser.default_open_content = default_open_content
self.parser.end_extension(extension, element)
self.assertIs(default_open_content, extension.open_content)
open_content = OpenContent()
extension.open_content = open_content
self.parser.end_extension(extension, element)
self.assertIs(open_content, extension.open_content)
def test_end_restriction(self):
restriction = Restriction()
not_restriction = Element()
element = etree.Element("uno")
self.parser.end_restriction(not_restriction, element)
self.parser.end_restriction(restriction, element)
default_open_content = DefaultOpenContent()
self.parser.default_open_content = default_open_content
self.parser.end_restriction(restriction, element)
self.assertIs(default_open_content, restriction.open_content)
open_content = OpenContent()
restriction.open_content = open_content
self.parser.end_restriction(restriction, element)
self.assertIs(open_content, restriction.open_content)
def test_property_real_type(self):
obj = Element.create()
self.assertIsNone(obj.real_type)
# Inner classes depend on the this to be None
obj.complex_type = ComplexType.create()
self.assertIsNone(obj.real_type)
restriction = Restriction.create(base="xs:int")
obj.simple_type = SimpleType.create(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.create(type="foo"))
obj.alternatives.append(Alternative.create(type="bar"))
obj.alternatives.append(Alternative.create(type="thug"))
self.assertEqual("bar foo thug", obj.real_type)
def test_build_class_extensions(self, mock_children_extensions):
bar_type = AttrTypeFactory.create(name="bar", index=3)
foo_type = AttrTypeFactory.create(name="foo", index=1)
some_type = AttrTypeFactory.create(name="something", index=0)
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.create(type="something")
self.builder.build_class_extensions(element, item)
self.assertEqual(3, len(item.extensions))
self.assertEqual(self_ext, item.extensions[0])
self.assertIs(foo, item.extensions[1])
self.assertIs(double, item.extensions[2])
def test_build_class(
self,
mock_real_name,
mock_display_help,
mock_is_nillable,
mock_is_abstract,
mock_substitutions,
mock_build_class_extensions,
mock_build_class_attributes,
mock_element_namespace,
):
mock_real_name.return_value = "name"
mock_display_help.return_value = "sos"
mock_is_abstract.return_value = True
mock_is_nillable.return_value = True
mock_substitutions.return_value = ["foo", "bar"]
mock_element_namespace.return_value = "foo:name"
element = Element.create()
result = self.builder.build_class(element)
mock_build_class_attributes.assert_called_once_with(element, result)
mock_build_class_extensions.assert_called_once_with(element, result)
mock_element_namespace.assert_called_once_with(element)
expected = ClassFactory.create(
name="name",
type=Element,
help="sos",
abstract=True,
nillable=True,
namespace="foo:name",
ns_map=element.ns_map,
package=self.builder.package,
module=self.schema.module,
source_namespace=self.schema.target_namespace,
substitutions=["foo", "bar"],
)
self.assertEqual(expected, result)
def test_property_substitutions(self):
obj = Element.create()
self.assertEqual([], obj.substitutions)
obj.substitution_group = "foo bar xs:any"
self.assertEqual(["foo", "bar", "xs:any"], obj.substitutions)
def test_property_is_attribute(self):
obj = Element.create()
self.assertTrue(obj)
def test_property_default_type(self):
obj = Element.create()
self.assertEqual(DataType.ANY_TYPE, obj.default_type)
def test_property_extends(self):
obj = Element.create()
self.assertIsNone(obj.extends)
