def test_complex_type_assertion(self):
schema = self.check_schema("""
<complexType name="intRange">
<attribute name="min" type="int"/>
<attribute name="max" type="int"/>
<assert test="@min le @max"/>
</complexType>""")
xsd_type = schema.types['intRange']
xsd_type.decode(etree_element('a', attrib={'min': '10', 'max': '19'}))
self.assertTrue(
xsd_type.is_valid(
etree_element('a', attrib={
'min': '10',
'max': '19'
})))
self.assertTrue(
xsd_type.is_valid(
etree_element('a', attrib={
'min': '19',
'max': '19'
})))
self.assertFalse(
xsd_type.is_valid(
etree_element('a', attrib={
'min': '25',
'max': '19'
})))
self.assertTrue(
xsd_type.is_valid(
etree_element('a', attrib={
'min': '25',
'max': '100'
})))
def test_etree_element_method(self):
converter = XMLSchemaConverter()
elem = converter.etree_element('A')
self.assertIsNone(etree_elements_assert_equal(elem, etree_element('A')))
elem = converter.etree_element('A', attrib={})
self.assertIsNone(etree_elements_assert_equal(elem, etree_element('A')))
def test_parse_component(self):
component = XMLSchema.meta_schema.types['anyType']
elem = etree_element(XSD_SCHEMA)
self.assertIsNone(component._parse_child_component(elem))
elem.append(etree_element(XSD_ELEMENT))
self.assertEqual(component._parse_child_component(elem), elem[0])
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertRaises(XMLSchemaParseError,
component._parse_child_component, elem)
self.assertEqual(component._parse_child_component(elem, strict=False),
elem[0])
elem.clear()
elem.append(etree_element(XSD_ANNOTATION))
self.assertIsNone(component._parse_child_component(elem))
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertEqual(component._parse_child_component(elem), elem[1])
elem.append(etree_element(XSD_ELEMENT))
self.assertRaises(XMLSchemaParseError,
component._parse_child_component, elem)
self.assertEqual(component._parse_child_component(elem, strict=False),
elem[1])
elem.clear()
elem.append(etree_element(XSD_ANNOTATION))
elem.append(etree_element(XSD_ANNOTATION))
self.assertIsNone(component._parse_child_component(elem, strict=False))
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertEqual(component._parse_child_component(elem), elem[2])
def test_complex_type_assertion(self):
schema = self.check_schema("""
<complexType name="intRange">
<attribute name="min" type="int"/>
<attribute name="max" type="int"/>
<assert test="@min le @max"/>
</complexType>""")
xsd_type = schema.types['intRange']
xsd_type.decode(etree_element('a', attrib={'min': '10', 'max': '19'}))
self.assertTrue(xsd_type.is_valid(etree_element('a', attrib={'min': '10', 'max': '19'})))
self.assertTrue(xsd_type.is_valid(etree_element('a', attrib={'min': '19', 'max': '19'})))
self.assertFalse(xsd_type.is_valid(etree_element('a', attrib={'min': '25', 'max': '19'})))
self.assertTrue(xsd_type.is_valid(etree_element('a', attrib={'min': '25', 'max': '100'})))
def test_has_xsd_components(self):
elem = etree_element(XSD_SCHEMA)
elem.append(etree_element(XSD_ELEMENT))
self.assertTrue(has_xsd_components(elem))
elem.clear()
self.assertFalse(has_xsd_components(elem))
elem.append(etree_element(XSD_ANNOTATION))
self.assertFalse(has_xsd_components(elem))
elem.append(etree_element(XSD_ELEMENT))
self.assertTrue(has_xsd_components(elem))
self.assertFalse(has_xsd_components(elem, start=1))
elem.append(etree_element(XSD_ANNOTATION))
self.assertRaises(ValueError, list, iter_xsd_components(elem))
def test_get_xsd_annotation(self):
elem = etree_element(XSD_SCHEMA)
self.assertIsNone(get_xsd_annotation(elem))
elem.append(etree_element(XSD_ANNOTATION))
self.assertEqual(get_xsd_annotation(elem), elem[0])
elem.append(etree_element(XSD_ELEMENT))
self.assertEqual(get_xsd_annotation(elem), elem[0])
elem.clear()
elem.append(etree_element(XSD_ELEMENT))
self.assertIsNone(get_xsd_annotation(elem))
elem.append(etree_element(XSD_ANNOTATION))
self.assertIsNone(get_xsd_annotation(elem))
def test_iter_xsd_components(self):
elem = etree_element(XSD_SCHEMA)
self.assertFalse(list(iter_xsd_components(elem)))
self.assertFalse(list(iter_xsd_components(elem, start=1)))
elem.append(etree_element(XSD_ANNOTATION))
self.assertFalse(list(iter_xsd_components(elem)))
self.assertFalse(list(iter_xsd_components(elem, start=1)))
elem.append(etree_element(XSD_ELEMENT))
self.assertEqual(list(iter_xsd_components(elem)), [elem[1]])
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertEqual(list(iter_xsd_components(elem)), elem[1:])
self.assertEqual(list(iter_xsd_components(elem, start=1)), [elem[2]])
elem.append(etree_element(XSD_ANNOTATION))
self.assertRaises(ValueError, list, iter_xsd_components(elem))
def test_iter_xsd_components(self):
elem = etree_element(XSD_SCHEMA)
self.assertFalse(list(iter_xsd_components(elem)))
self.assertFalse(list(iter_xsd_components(elem, start=1)))
elem.append(etree_element(XSD_ANNOTATION))
self.assertFalse(list(iter_xsd_components(elem)))
self.assertFalse(list(iter_xsd_components(elem, start=1)))
elem.append(etree_element(XSD_ELEMENT))
self.assertEqual(list(iter_xsd_components(elem)), [elem[1]])
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertEqual(list(iter_xsd_components(elem)), elem[1:])
self.assertEqual(list(iter_xsd_components(elem, start=1)), [elem[2]])
elem.append(etree_element(XSD_ANNOTATION))
self.assertRaises(ValueError, list, iter_xsd_components(elem))
def test_get_xsd_annotation(self):
elem = etree_element(XSD_SCHEMA)
self.assertIsNone(get_xsd_annotation(elem))
elem.append(etree_element(XSD_ANNOTATION))
self.assertEqual(get_xsd_annotation(elem), elem[0])
elem.append(etree_element(XSD_ELEMENT))
self.assertEqual(get_xsd_annotation(elem), elem[0])
elem.clear()
elem.append(etree_element(XSD_ELEMENT))
self.assertIsNone(get_xsd_annotation(elem))
elem.append(etree_element(XSD_ANNOTATION))
self.assertIsNone(get_xsd_annotation(elem))
def test_has_xsd_components(self):
elem = etree_element(XSD_SCHEMA)
elem.append(etree_element(XSD_ELEMENT))
self.assertTrue(has_xsd_components(elem))
elem.clear()
self.assertFalse(has_xsd_components(elem))
elem.append(etree_element(XSD_ANNOTATION))
self.assertFalse(has_xsd_components(elem))
elem.append(etree_element(XSD_ELEMENT))
self.assertTrue(has_xsd_components(elem))
self.assertFalse(has_xsd_components(elem, start=1))
elem.append(etree_element(XSD_ANNOTATION))
self.assertRaises(ValueError, list, iter_xsd_components(elem))
def test_simple_elements(self):
elem = etree_element('A')
elem.text = '89'
self.check_encode(self.get_element('A', type='xs:string'), '89', elem)
self.check_encode(self.get_element('A', type='xs:integer'), 89, elem)
elem.text = '-10.4'
self.check_encode(self.get_element('A', type='xs:float'), -10.4, elem)
elem.text = 'false'
self.check_encode(self.get_element('A', type='xs:boolean'), False,
elem)
elem.text = 'true'
self.check_encode(self.get_element('A', type='xs:boolean'), True, elem)
self.check_encode(self.get_element('A', type='xs:short'), 128000,
XMLSchemaValidationError)
elem.text = '0'
self.check_encode(self.get_element('A', type='xs:nonNegativeInteger'),
0, elem)
self.check_encode(self.get_element('A', type='xs:nonNegativeInteger'),
'0', XMLSchemaValidationError)
self.check_encode(self.get_element('A', type='xs:positiveInteger'), 0,
XMLSchemaValidationError)
elem.text = '-1'
self.check_encode(self.get_element('A', type='xs:negativeInteger'), -1,
elem)
self.check_encode(self.get_element('A', type='xs:nonNegativeInteger'),
-1, XMLSchemaValidationError)
def retrieve_schema_source(self, source):
"""
Returns a schema source that can be used to create an XMLSchema instance.
:param source: A string or an ElementTree's Element.
:return: An schema source string, an ElementTree's Element or a full pathname.
"""
if is_etree_element(source):
if source.tag in (XSD_SCHEMA, 'schema'):
return source
elif get_namespace(source.tag):
raise XMLSchemaValueError("source %r namespace has to be empty." % source)
elif source.tag not in {'element', 'attribute', 'simpleType', 'complexType',
'group', 'attributeGroup', 'notation'}:
raise XMLSchemaValueError("% is not an XSD global definition/declaration." % source)
root = etree_element('schema', attrib={
'xmlns:ns': "ns",
'xmlns': "http://www.w3.org/2001/XMLSchema",
'targetNamespace': "ns",
'elementFormDefault': "qualified",
'version': self.schema_class.XSD_VERSION,
})
root.append(source)
return root
else:
source = source.strip()
if not source.startswith('<'):
return self.casepath(source)
else:
return self.SCHEMA_TEMPLATE.format(self.schema_class.XSD_VERSION, source)
def retrieve_schema_source(self, source):
"""
Returns a schema source that can be used to create an XMLSchema instance.
:param source: A string or an ElementTree's Element.
:return: An schema source string, an ElementTree's Element or a full pathname.
"""
if is_etree_element(source):
if source.tag in (XSD_SCHEMA, 'schema'):
return source
elif get_namespace(source.tag):
raise XMLSchemaValueError("source %r namespace has to be empty." % source)
elif source.tag not in {'element', 'attribute', 'simpleType', 'complexType',
'group', 'attributeGroup', 'notation'}:
raise XMLSchemaValueError("% is not an XSD global definition/declaration." % source)
root = etree_element('schema', attrib={
'xmlns:ns': "ns",
'xmlns': "http://www.w3.org/2001/XMLSchema",
'targetNamespace': "ns",
'elementFormDefault': "qualified",
'version': self.schema_class.XSD_VERSION,
})
root.append(source)
return root
else:
source = source.strip()
if not source.startswith('<'):
return self.casepath(source)
else:
return self.SCHEMA_TEMPLATE.format(self.schema_class.XSD_VERSION, source)
def test_get_xml_bool_attribute(self):
elem = etree_element(XSD_ELEMENT,
attrib={
'a1': 'true',
'a2': '1',
'a3': 'false',
'a4': '0',
'a5': 'x'
})
self.assertEqual(get_xml_bool_attribute(elem, 'a1'), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a2'), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a3'), False)
self.assertEqual(get_xml_bool_attribute(elem, 'a4'), False)
self.assertRaises(TypeError, get_xml_bool_attribute, elem, 'a5')
self.assertRaises(KeyError, get_xml_bool_attribute, elem, 'a6')
self.assertEqual(get_xml_bool_attribute(elem, 'a6', True), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', 'true'), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', '1'), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', False), False)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', 'false'), False)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', '0'), False)
self.assertRaises(TypeError, get_xml_bool_attribute, elem, 'a6', 1)
self.assertRaises(TypeError, get_xml_bool_attribute, elem, 'a6', 0)
self.assertRaises(TypeError, get_xml_bool_attribute, elem, 'a6',
'True')
def test_get_xpath_default_namespace(self):
elem = etree_element(XSD_ELEMENT,
attrib={'xpathDefaultNamespace': '##local '})
self.assertEqual(
get_xpath_default_namespace(elem, 'ns0', 'ns1', 'ns2'), '')
elem = etree_element(
XSD_ELEMENT,
attrib={'xpathDefaultNamespace': ' ##defaultNamespace'})
self.assertEqual(
get_xpath_default_namespace(elem, 'ns0', 'ns1', 'ns2'), 'ns0')
elem = etree_element(
XSD_ELEMENT,
attrib={'xpathDefaultNamespace': ' ##targetNamespace'})
self.assertEqual(
get_xpath_default_namespace(elem, 'ns0', 'ns1', 'ns2'), 'ns1')
elem = etree_element(XSD_ELEMENT)
self.assertIsNone(get_xpath_default_namespace(elem, 'ns0', 'ns1'))
self.assertEqual(
get_xpath_default_namespace(elem, 'ns0', 'ns1', 'ns2'), 'ns2')
elem = etree_element(XSD_ELEMENT,
attrib={'xpathDefaultNamespace': 'ns3'})
self.assertEqual(
get_xpath_default_namespace(elem, 'ns0', 'ns1', 'ns2'), 'ns3')
elem = etree_element(XSD_ELEMENT,
attrib={'xpathDefaultNamespace': 'ns3 ns4'})
self.assertRaises(ValueError, get_xpath_default_namespace, elem, 'ns0',
'ns1', 'ns2')
def test_get_xsd_form_attribute(self):
elem = etree_element(XSD_ELEMENT,
attrib={
'a1': 'qualified',
'a2': ' qualified',
'a3': 'unqualified',
'a4': ''
})
self.assertEqual(get_xsd_form_attribute(elem, 'a1'), 'qualified')
self.assertRaises(ValueError, get_xsd_form_attribute, elem, 'a2')
self.assertEqual(get_xsd_form_attribute(elem, 'a3'), 'unqualified')
self.assertRaises(ValueError, get_xsd_form_attribute, elem, 'a4')
self.assertIsNone(get_xsd_form_attribute(elem, 'a5'))
def test_get_xsd_derivation_attribute(self):
elem = etree_element(XSD_ELEMENT, attrib={
'a1': 'extension', 'a2': ' restriction', 'a3': '#all', 'a4': 'other',
'a5': 'restriction extension restriction ', 'a6': 'other restriction'
})
values = ('extension', 'restriction')
self.assertEqual(get_xsd_derivation_attribute(elem, 'a1', values), 'extension')
self.assertEqual(get_xsd_derivation_attribute(elem, 'a2', values), ' restriction')
self.assertEqual(get_xsd_derivation_attribute(elem, 'a3', values), 'extension restriction')
self.assertRaises(ValueError, get_xsd_derivation_attribute, elem, 'a4', values)
self.assertEqual(get_xsd_derivation_attribute(elem, 'a5', values), 'restriction extension restriction ')
self.assertRaises(ValueError, get_xsd_derivation_attribute, elem, 'a6', values)
self.assertEqual(get_xsd_derivation_attribute(elem, 'a7', values), '')
def test_get_xml_bool_attribute(self):
elem = etree_element(XSD_ELEMENT, attrib={'a1': 'true', 'a2': '1', 'a3': 'false', 'a4': '0', 'a5': 'x'})
self.assertEqual(get_xml_bool_attribute(elem, 'a1'), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a2'), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a3'), False)
self.assertEqual(get_xml_bool_attribute(elem, 'a4'), False)
self.assertRaises(TypeError, get_xml_bool_attribute, elem, 'a5')
self.assertRaises(KeyError, get_xml_bool_attribute, elem, 'a6')
self.assertEqual(get_xml_bool_attribute(elem, 'a6', True), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', 'true'), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', '1'), True)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', False), False)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', 'false'), False)
self.assertEqual(get_xml_bool_attribute(elem, 'a6', '0'), False)
self.assertRaises(TypeError, get_xml_bool_attribute, elem, 'a6', 1)
self.assertRaises(TypeError, get_xml_bool_attribute, elem, 'a6', 0)
self.assertRaises(TypeError, get_xml_bool_attribute, elem, 'a6', 'True')
def test_get_xsd_component(self):
elem = etree_element(XSD_SCHEMA)
self.assertRaises(ValueError, get_xsd_component, elem)
self.assertIsNone(get_xsd_component(elem, required=False))
elem.append(etree_element(XSD_ELEMENT))
self.assertEqual(get_xsd_component(elem), elem[0])
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertRaises(ValueError, get_xsd_component, elem)
self.assertEqual(get_xsd_component(elem, strict=False), elem[0])
elem.clear()
elem.append(etree_element(XSD_ANNOTATION))
self.assertRaises(ValueError, get_xsd_component, elem)
self.assertIsNone(get_xsd_component(elem, required=False))
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertEqual(get_xsd_component(elem), elem[1])
elem.append(etree_element(XSD_ELEMENT))
self.assertRaises(ValueError, get_xsd_component, elem)
self.assertEqual(get_xsd_component(elem, strict=False), elem[1])
elem.clear()
elem.append(etree_element(XSD_ANNOTATION))
elem.append(etree_element(XSD_ANNOTATION))
self.assertRaises(ValueError, get_xsd_component, elem, True, False)
def test_get_xsd_component(self):
elem = etree_element(XSD_SCHEMA)
self.assertRaises(ValueError, get_xsd_component, elem)
self.assertIsNone(get_xsd_component(elem, required=False))
elem.append(etree_element(XSD_ELEMENT))
self.assertEqual(get_xsd_component(elem), elem[0])
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertRaises(ValueError, get_xsd_component, elem)
self.assertEqual(get_xsd_component(elem, strict=False), elem[0])
elem.clear()
elem.append(etree_element(XSD_ANNOTATION))
self.assertRaises(ValueError, get_xsd_component, elem)
self.assertIsNone(get_xsd_component(elem, required=False))
elem.append(etree_element(XSD_SIMPLE_TYPE))
self.assertEqual(get_xsd_component(elem), elem[1])
elem.append(etree_element(XSD_ELEMENT))
self.assertRaises(ValueError, get_xsd_component, elem)
self.assertEqual(get_xsd_component(elem, strict=False), elem[1])
elem.clear()
elem.append(etree_element(XSD_ANNOTATION))
elem.append(etree_element(XSD_ANNOTATION))
self.assertRaises(ValueError, get_xsd_component, elem, True, False)
def test_get_xsd_derivation_attribute(self):
elem = etree_element(XSD_ELEMENT,
attrib={
'a1': 'extension',
'a2': ' restriction',
'a3': '#all',
'a4': 'other',
'a5': 'restriction extension restriction ',
'a6': 'other restriction'
})
values = ('extension', 'restriction')
self.assertEqual(get_xsd_derivation_attribute(elem, 'a1', values),
'extension')
self.assertEqual(get_xsd_derivation_attribute(elem, 'a2', values),
' restriction')
self.assertEqual(get_xsd_derivation_attribute(elem, 'a3', values),
'extension restriction')
self.assertRaises(ValueError, get_xsd_derivation_attribute, elem, 'a4',
values)
self.assertEqual(get_xsd_derivation_attribute(elem, 'a5', values),
'restriction extension restriction ')
self.assertRaises(ValueError, get_xsd_derivation_attribute, elem, 'a6',
values)
self.assertEqual(get_xsd_derivation_attribute(elem, 'a7', values), '')
