def test_parse_boolean_attribute(self):
name = '{%s}motorbikes' % self.schema.target_namespace
elem = ElementTree.Element(XSD_ELEMENT, name=name, flag='true')
xsd_element = self.FakeElement(elem=elem,
name=name,
schema=self.schema,
parent=None)
self.assertIsNone(xsd_element._parse_boolean_attribute('cond'))
self.assertTrue(xsd_element._parse_boolean_attribute('flag'))
xsd_element.elem = ElementTree.Element(XSD_ELEMENT,
name=name,
flag='1')
self.assertTrue(xsd_element._parse_boolean_attribute('flag'))
xsd_element.elem = ElementTree.Element(XSD_ELEMENT,
name=name,
flag='false')
self.assertFalse(xsd_element._parse_boolean_attribute('flag'))
xsd_element.elem = ElementTree.Element(XSD_ELEMENT,
name=name,
flag='0')
self.assertFalse(xsd_element._parse_boolean_attribute('flag'))
xsd_element.elem = ElementTree.Element(XSD_ELEMENT,
name=name,
flag='False')
with self.assertRaises(XMLSchemaParseError):
xsd_element._parse_boolean_attribute('flag')
def test_wsdl_component(self):
wsdl_document = Wsdl11Document(WSDL_DOCUMENT_EXAMPLE)
elem = ElementTree.Element('foo', bar='abc')
wsdl_component = WsdlComponent(elem, wsdl_document)
self.assertIsNone(wsdl_component.prefixed_name)
self.assertIs(wsdl_component.attrib, elem.attrib)
self.assertEqual(wsdl_component.get('bar'), 'abc')
elem = ElementTree.Element('foo', name='bar')
wsdl_component = WsdlComponent(elem, wsdl_document)
self.assertEqual(wsdl_component.prefixed_name, 'tns:bar')
self.assertEqual(
wsdl_component.map_qname(
'{http://example.com/stockquote.wsdl}bar'), 'tns:bar')
self.assertEqual(wsdl_component.unmap_qname('tns:bar'),
'{http://example.com/stockquote.wsdl}bar')
elem = ElementTree.Element('foo', a1='tns:bar', a2='unknown:bar')
self.assertEqual(wsdl_component._parse_reference(elem, 'a1'),
'{http://example.com/stockquote.wsdl}bar')
self.assertEqual(wsdl_component._parse_reference(elem, 'a2'),
'unknown:bar')
self.assertIsNone(wsdl_component._parse_reference(elem, 'a3'))
def test_parse_child_component(self):
name = '{%s}motorbikes' % self.schema.target_namespace
elem = ElementTree.Element(XSD_ELEMENT, name=name)
elem.append(ElementTree.Element(XSD_ANNOTATION))
elem.append(ElementTree.Element('child1'))
elem.append(ElementTree.Element('child2'))
xsd_element = self.FakeElement(elem=elem,
name=name,
schema=self.schema,
parent=None)
self.assertEqual(
xsd_element._parse_child_component(elem, strict=False), elem[1])
with self.assertRaises(XMLSchemaParseError):
xsd_element._parse_child_component(elem)
def test_iter_components(self):
name = '{%s}motorbikes' % self.schema.target_namespace
elem = ElementTree.Element(XSD_ELEMENT, name=name)
xsd_element = self.FakeElement(elem, self.schema, parent=None, name=name)
self.assertListEqual(list(xsd_element.iter_components()), [xsd_element])
self.assertListEqual(list(xsd_element.iter_components(str)), [])
def test_element_string_serialization(self):
self.assertRaises(TypeError, etree_tostring, '<element/>')
elem = ElementTree.Element('element')
self.assertEqual(etree_tostring(elem), '<element />')
self.assertEqual(etree_tostring(elem, xml_declaration=True), '<element />')
self.assertEqual(etree_tostring(elem, encoding='us-ascii'), b'<element />')
self.assertEqual(etree_tostring(elem, encoding='us-ascii', indent=' '),
b' <element />')
self.assertEqual(etree_tostring(elem, encoding='us-ascii', xml_declaration=True),
b'<?xml version="1.0" encoding="us-ascii"?>\n<element />')
self.assertEqual(etree_tostring(elem, encoding='ascii'),
b"<?xml version='1.0' encoding='ascii'?>\n<element />")
self.assertEqual(etree_tostring(elem, encoding='ascii', xml_declaration=False),
b'<element />')
self.assertEqual(etree_tostring(elem, encoding='utf-8'), b'<element />')
self.assertEqual(etree_tostring(elem, encoding='utf-8', xml_declaration=True),
b'<?xml version="1.0" encoding="utf-8"?>\n<element />')
self.assertEqual(etree_tostring(elem, encoding='iso-8859-1'),
b"<?xml version='1.0' encoding='iso-8859-1'?>\n<element />")
self.assertEqual(etree_tostring(elem, encoding='iso-8859-1', xml_declaration=False),
b"<element />")
self.assertEqual(etree_tostring(elem, method='html'), '<element></element>')
self.assertEqual(etree_tostring(elem, method='text'), '')
root = ElementTree.XML('<root>\n'
' text1\n'
' <elem>text2</elem>\n'
'</root>')
self.assertEqual(etree_tostring(root, method='text'), '\n text1\n text2')
def test_any_type(self):
any_type = xmlschema.XMLSchema.meta_schema.types['anyType']
xml_data_1 = ElementTree.Element('dummy')
self.assertIsNone(any_type.decode(xml_data_1))
xml_data_2 = ElementTree.fromstring(
'<root>\n <child_1/>\n <child_2/>\n</root>')
self.assertIsNone(
any_type.decode(xml_data_2)) # Currently no decoding yet
def test_id_property(self):
name = '{%s}motorbikes' % self.schema.target_namespace
elem = ElementTree.Element(XSD_ELEMENT, name=name, id='1999')
xsd_element = self.FakeElement(elem=elem,
name=name,
schema=self.schema,
parent=None)
self.assertEqual(xsd_element.id, '1999')
def test_initialization(self):
schema_proxy = XMLSchemaProxy()
self.assertIs(schema_proxy._schema, self.schema_class.meta_schema)
schema_proxy = XMLSchemaProxy(self.xs1, base_element=self.xs1.elements['vehicles'])
self.assertIs(schema_proxy._schema, self.xs1)
with self.assertRaises(ValueError):
XMLSchemaProxy(self.xs1, base_element=self.xs2.elements['collection'])
with self.assertRaises(TypeError):
XMLSchemaProxy(self.xs1, base_element=ElementTree.Element('vehicles'))
def test_parse_xpath_default_namespace(self):
xsd_text = """<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root"/>
</xs:schema>"""
schema = XMLSchema11(xsd_text)
elem = ElementTree.Element('A')
self.assertEqual(schema._parse_xpath_default_namespace(elem), '')
elem = ElementTree.Element('A', xpathDefaultNamespace='##local')
self.assertEqual(schema._parse_xpath_default_namespace(elem), '')
elem = ElementTree.Element('A',
xpathDefaultNamespace='##defaultNamespace')
self.assertEqual(schema._parse_xpath_default_namespace(elem), '')
elem = ElementTree.Element('A',
xpathDefaultNamespace='##targetNamespace')
self.assertEqual(schema._parse_xpath_default_namespace(elem), '')
xsd_text = """<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="tns0" targetNamespace="tns0">
<xs:element name="root"/>
</xs:schema>"""
schema = XMLSchema11(xsd_text, validation='lax')
elem = ElementTree.Element('A')
self.assertEqual(schema._parse_xpath_default_namespace(elem), '')
elem = ElementTree.Element('A', xpathDefaultNamespace='##local')
self.assertEqual(schema._parse_xpath_default_namespace(elem), '')
elem = ElementTree.Element('A',
xpathDefaultNamespace='##defaultNamespace')
self.assertEqual(schema._parse_xpath_default_namespace(elem), 'tns0')
elem = ElementTree.Element('A',
xpathDefaultNamespace='##targetNamespace')
self.assertEqual(schema._parse_xpath_default_namespace(elem), 'tns0')
elem = ElementTree.Element('A', xpathDefaultNamespace='tns1')
self.assertEqual(schema._parse_xpath_default_namespace(elem), 'tns1')
elem = ElementTree.Element('A', xpathDefaultNamespace='tns0 tns1')
self.assertEqual(schema._parse_xpath_default_namespace(elem), '')
self.assertIn('tns0 tns1', schema.errors[-1].message)
def test_parse(self):
schema = self.schema_class("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:notation name="content" public="text/html"/>
</xs:schema>""")
self.assertIn('content', schema.notations)
with self.assertRaises(XMLSchemaParseError) as ctx:
self.schema_class("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:notation name="content"/>
</xs:schema>""")
self.assertIn("notation must have a 'public' or a 'system' attribute",
str(ctx.exception))
with self.assertRaises(XMLSchemaParseError) as ctx:
self.schema_class("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:notation public="text/html"/>
</xs:schema>""")
self.assertEqual("missing required attribute 'name'",
ctx.exception.message)
schema = self.schema_class("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:notation public="text/html"/>
</xs:schema>""",
validation='skip')
self.assertListEqual(schema.all_errors, [])
schema = self.schema_class("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:notation public="text/html"/>
</xs:schema>""",
validation='lax')
self.assertEqual(len(schema.all_errors), 2)
schema = self.schema_class("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="emptyType"/>
</xs:schema>""")
elem = ElementTree.Element(XSD_NOTATION)
with self.assertRaises(XMLSchemaParseError) as ctx:
XsdNotation(elem, schema, parent=schema.types['emptyType'])
self.assertIn("a notation declaration must be global",
str(ctx.exception))
with self.assertRaises(XMLSchemaParseError) as ctx:
XsdNotation(elem, schema, parent=None)
self.assertIn("a notation must have a 'name' attribute",
str(ctx.exception))
def test_name_matching(self):
name = '{%s}motorbikes' % self.schema.target_namespace
elem = ElementTree.Element(XSD_ELEMENT, name=name)
xsd_element = self.FakeElement(elem, self.schema, parent=None, name=name)
self.assertFalse(xsd_element.is_matching('motorbikes'))
self.assertFalse(xsd_element.is_matching(''))
self.assertTrue(
xsd_element.is_matching('motorbikes', default_namespace=self.schema.target_namespace)
)
self.assertFalse(xsd_element.is_matching('{%s}bikes' % self.schema.target_namespace))
self.assertTrue(xsd_element.is_matching(name))
self.assertIs(xsd_element.match(name), xsd_element)
def test_parse_particle(self):
schema = XMLSchema10(
"""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root"/>
</xs:schema>""")
xsd_element = schema.elements['root']
elem = ElementTree.Element('root', minOccurs='1', maxOccurs='1')
xsd_element._parse_particle(elem)
elem = ElementTree.Element('root', minOccurs='2', maxOccurs='1')
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_particle(elem)
self.assertIn(
"maxOccurs must be 'unbounded' or greater than minOccurs",
str(ctx.exception))
elem = ElementTree.Element('root', minOccurs='-1', maxOccurs='1')
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_particle(elem)
self.assertIn("minOccurs value must be a non negative integer",
str(ctx.exception))
elem = ElementTree.Element('root', minOccurs='1', maxOccurs='-1')
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_particle(elem)
self.assertIn(
"maxOccurs must be 'unbounded' or greater than minOccurs",
str(ctx.exception))
elem = ElementTree.Element('root', minOccurs='1', maxOccurs='none')
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_particle(elem)
self.assertIn(
"maxOccurs value must be a non negative integer or 'unbounded'",
str(ctx.exception))
elem = ElementTree.Element('root', minOccurs='2')
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_particle(elem)
self.assertIn("minOccurs must be lesser or equal than maxOccurs",
str(ctx.exception))
elem = ElementTree.Element('root', minOccurs='none')
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_particle(elem)
self.assertIn("minOccurs value is not an integer value",
str(ctx.exception))
def test_parse_reference(self):
group = self.schema.elements['vehicles'].type.content
name = '{%s}motorbikes' % XSD_NAMESPACE
elem = ElementTree.Element(XSD_ELEMENT, name=name)
xsd_element = self.FakeElement(elem=elem, name=name, schema=self.schema, parent=None)
self.assertIsNone(xsd_element._parse_reference())
elem = ElementTree.Element(XSD_ELEMENT, name=name, ref=name)
xsd_element = self.FakeElement(elem=elem, name=name, schema=self.schema, parent=None)
with self.assertRaises(XMLSchemaParseError):
xsd_element._parse_reference()
elem = ElementTree.Element(XSD_ELEMENT, ref=name)
xsd_element = self.FakeElement(elem=elem, name=name, schema=self.schema, parent=None)
with self.assertRaises(XMLSchemaParseError):
xsd_element._parse_reference()
xsd_element = self.FakeElement(elem=elem, name=name, schema=self.schema, parent=group)
xsd_element._parse_reference()
elem = ElementTree.Element(XSD_ELEMENT, ref='tns0:motorbikes')
xsd_element = self.FakeElement(elem=elem, name=name, schema=self.schema, parent=group)
with self.assertRaises(XMLSchemaParseError):
xsd_element._parse_reference()
elem = ElementTree.Element(XSD_ELEMENT, ref=name)
elem.append(ElementTree.Element('child'))
xsd_element = self.FakeElement(elem=elem, name=name, schema=self.schema, parent=group)
with self.assertRaises(XMLSchemaParseError):
xsd_element._parse_reference()
elem = ElementTree.Element(XSD_ELEMENT)
xsd_element = self.FakeElement(elem=elem, name=name, schema=self.schema, parent=None)
with self.assertRaises(XMLSchemaParseError):
xsd_element._parse_reference()
xsd_element = self.FakeElement(elem=elem, name=name, schema=self.schema, parent=group)
with self.assertRaises(XMLSchemaParseError):
xsd_element._parse_reference()
def test_parse_target_namespace(self):
name = '{%s}motorbikes' % self.schema.target_namespace
elem = ElementTree.Element(XSD_ELEMENT,
name=name,
targetNamespace='tns0')
group = self.schema.elements['vehicles'].type.content
xsd_element = self.FakeElement(elem=elem,
name=name,
schema=self.schema,
parent=None)
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_target_namespace()
self.assertIn("must have the same namespace", ctx.exception.message)
xsd_element = self.FakeElement(elem=elem,
name=name,
schema=self.schema,
parent=group)
self.assertIsNone(xsd_element._parse_target_namespace())
self.assertEqual(xsd_element.name, '{tns0}motorbikes')
elem = ElementTree.Element(XSD_ELEMENT, targetNamespace='tns0')
xsd_element = self.FakeElement(elem=elem,
name=None,
schema=self.schema,
parent=group)
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_target_namespace()
self.assertIn("attribute 'name' must be present",
ctx.exception.message)
elem = ElementTree.Element(XSD_ELEMENT,
name=name,
form='qualified',
targetNamespace='tns0')
xsd_element = self.FakeElement(elem=elem,
name=name,
schema=self.schema,
parent=group)
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_element._parse_target_namespace()
self.assertIn("attribute 'form' must be absent", ctx.exception.message)
elem = ElementTree.Element(
XSD_ELEMENT,
name='motobikes',
targetNamespace=self.schema.target_namespace)
xsd_element = self.FakeElement(elem,
self.schema,
parent=group,
name=name)
self.assertIsNone(xsd_element._parse_target_namespace())
self.assertEqual(xsd_element.name, name)
xsd_attribute = self.schema.types['vehicleType'].attributes['model']
xsd_attribute.elem.attrib['targetNamespace'] = 'tns0'
with self.assertRaises(XMLSchemaParseError) as ctx:
xsd_attribute._parse_target_namespace()
self.assertIn(
"a declaration contained in a global complexType must "
"have the same namespace", ctx.exception.message)
del xsd_attribute.elem.attrib['targetNamespace']
with self.assertRaises(XMLSchemaParseError) as ctx:
XMLSchema11(
"""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" targetNamespace=""/>
</xs:schema>""")
self.assertIn("use of attribute 'targetNamespace' is prohibited",
ctx.exception.message)
schema = XMLSchema11(
"""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="type0">
<xs:sequence>
<xs:any namespace="http://xmlschema.test/ns"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="type1">
<xs:complexContent>
<xs:restriction base="type0">
<xs:sequence>
<xs:element name="elem1" targetNamespace="http://xmlschema.test/ns"
type="xs:integer"/>
</xs:sequence>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
<xs:element name="root" type="type1"/>
</xs:schema>""")
self.assertEqual(
schema.elements['root'].type.content[0].target_namespace,
'http://xmlschema.test/ns')
schema = XMLSchema11(
"""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root">
<xs:complexType>
<xs:sequence>
<xs:element name="node" targetNamespace=""/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>""")
self.assertEqual(schema.elements['root'].type.content[0].name, 'node')
def test_initialization(self):
with self.assertRaises(AttributeError):
XsdComponent(elem=None, schema=self.schema)
with self.assertRaises(ValueError):
XsdComponent(elem=ElementTree.Element('A'), schema=self.schema)