Python源码示例：xmlschema.XMLSchema()
示例1
def test_nillable(self):
# Issue #76
xsd_string = """<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="foo" type="Foo" />
<xs:complexType name="Foo">
<xs:sequence minOccurs="1" maxOccurs="1">
<xs:element name="bar" type="xs:integer" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:schema>
"""
xsd_schema = xmlschema.XMLSchema(xsd_string)
xml_string_1 = "<foo><bar>0</bar></foo>"
xml_string_2 = """<?xml version="1.0" encoding="UTF-8"?>
<foo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<bar xsi:nil="true"></bar>
</foo>
"""
self.assertTrue(xsd_schema.is_valid(source=xml_string_1, use_defaults=False))
self.assertTrue(xsd_schema.is_valid(source=xml_string_2, use_defaults=False))
obj = xsd_schema.decode(xml_string_2, use_defaults=False)
self.check_etree_elements(ElementTree.fromstring(xml_string_2), xsd_schema.encode(obj))
示例2
def test_decoding_errors_with_validation_modes(self):
schema = self.schema_class("""<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="rootType" />
<xs:complexType name="rootType">
<xs:simpleContent>
<xs:extension base="xs:int">
<xs:attribute name="int_attr" type="xs:int"/>
<xs:attribute name="bool_attr" type="xs:boolean"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:element name="simple_root" type="xs:float"/>
</xs:schema>""")
self.assertIsNone(schema.to_dict("<simple_root>alpha</simple_root>", validation='lax')[0])
self.assertEqual(schema.to_dict("<root int_attr='10'>20</root>"),
{'@int_attr': 10, '$': 20})
self.assertEqual(schema.to_dict("<root int_attr='wrong'>20</root>", validation='lax')[0],
{'@int_attr': None, '$': 20})
self.assertEqual(schema.to_dict("<root int_attr='wrong'>20</root>", validation='skip'),
{'@int_attr': 'wrong', '$': 20})
示例3
def test_max_depth_argument(self):
schema = self.schema_class(self.col_xsd_file)
self.assertEqual(
schema.decode(self.col_xml_file, max_depth=1),
{'@xmlns:col': 'http://example.com/ns/collection',
'@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
'@xsi:schemaLocation': 'http://example.com/ns/collection collection.xsd'})
xmlschema.limits.MAX_XML_DEPTH = 1
with self.assertRaises(XMLSchemaValidationError):
schema.decode(self.col_xml_file)
xmlschema.limits.MAX_XML_DEPTH = 9999
self.assertEqual(
schema.decode(self.col_xml_file, max_depth=2),
{'@xmlns:col': 'http://example.com/ns/collection',
'@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
'@xsi:schemaLocation': 'http://example.com/ns/collection collection.xsd',
'object': [{'@id': 'b0836217462', '@available': True},
{'@id': 'b0836217463', '@available': True}]})
示例4
def test_cdata_mapping(self):
schema = XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="node" type="xs:string" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
""")
self.assertEqual(
schema.decode('<root>1<node/>2<node/>3</root>'), {'node': [None, None]}
)
self.assertEqual(
schema.decode('<root>1<node/>2<node/>3</root>', cdata_prefix='#'),
{'#1': '1', 'node': [None, None], '#2': '2', '#3': '3'}
)
示例5
def test_exception_init(self):
xs = XMLSchema(os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd'))
with self.assertRaises(ValueError) as ctx:
XMLSchemaValidatorError(xs, 'unknown error', elem='wrong')
self.assertIn("'elem' attribute requires an Element", str(ctx.exception))
error = XMLSchemaNotBuiltError(xs, 'schema not built!')
self.assertEqual(error.message, 'schema not built!')
schema = XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:group name="group1">
<xs:choice>
<xs:element name="root" type="xs:integer"/>
</xs:choice>
</xs:group>
</xs:schema>""")
error = XMLSchemaModelDepthError(schema.groups['group1'])
self.assertEqual("maximum model recursion depth exceeded", error.message[:38])
示例6
def test_setattr(self):
schema = XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="xs:integer"/>
</xs:schema>""")
root = ElementTree.XML('<root a="10"/>')
with self.assertRaises(XMLSchemaValidationError) as ctx:
schema.validate(root)
self.assertIsInstance(ctx.exception.source, XMLResource)
self.assertFalse(ctx.exception.source.is_lazy())
resource = XMLResource(io.StringIO('<root a="10"/>'), lazy=True)
with self.assertRaises(XMLSchemaValidationError) as ctx:
schema.validate(resource)
self.assertIsInstance(ctx.exception.source, XMLResource)
self.assertTrue(ctx.exception.source.is_lazy())
self.assertIsNone(ctx.exception.elem)
self.assertEqual(ctx.exception.source, resource)
self.assertEqual(ctx.exception.path, '/root')
示例7
def test_properties(self):
schema = XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="xs:integer"/>
</xs:schema>""")
root = lxml.etree.XML('<root a="10"/>')
with self.assertRaises(XMLSchemaValidationError) as ctx:
schema.validate(root)
self.assertEqual(ctx.exception.sourceline, 1)
self.assertEqual(ctx.exception.root, root)
xsd_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd')
xs = XMLSchema(xsd_file)
with self.assertRaises(XMLSchemaValidatorError) as ctx:
raise XMLSchemaValidatorError(xs, 'unknown error')
self.assertIsNone(ctx.exception.root)
self.assertIsNone(ctx.exception.schema_url)
self.assertEqual(ctx.exception.origin_url, xs.source.url)
self.assertIsNone(XMLSchemaValidatorError(None, 'unknown error').origin_url)
示例8
def _validate_openscenario_configuration(self):
"""
Validate the given OpenSCENARIO config against the 0.9.1 XSD
Note: This will throw if the config is not valid. But this is fine here.
"""
xsd_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../openscenario/OpenSCENARIO.xsd")
xsd = xmlschema.XMLSchema(xsd_file)
xsd.validate(self.xml_tree)
示例9
def _validate_openscenario_catalog_configuration(self, catalog_xml_tree):
"""
Validate the given OpenSCENARIO catalog config against the 0.9.1 XSD
Note: This will throw if the catalog config is not valid. But this is fine here.
"""
xsd_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../openscenario/OpenSCENARIO.xsd")
xsd = xmlschema.XMLSchema(xsd_file)
xsd.validate(catalog_xml_tree)
示例10
def _validate(xml, schemapath):
"""Validates given XML file/element with a given schema
:xml: parsed xml element/file
:schemapath: path to a schema file
"""
schema = xmlschema.XMLSchema(schemapath)
for error in schema.iter_errors(xml):
print(error)
return schema.is_valid(xml)
示例11
def setUpClass(cls):
print("Starting pmml validation tests.")
data = datasets.load_iris()
cls.X = data.data
cls.y = data.target
cls.y_bin = [i%2 for i in range(cls.X.shape[0])]
cls.features = data.feature_names
data = datasets.load_boston()
cls.X_reg = data.data
cls.y_reg = data.target
cls.features_reg = data.feature_names
cls.schema = xmlschema.XMLSchema("nyoka/pmml44.xsd")
cls.statsmodels_data_helper = StatsmodelsDataHelper()
示例12
def schema():
"""Returns a xmlschema.XMLSchema object for the junit-10.xsd file"""
fn = Path(__file__).parent / "example_scripts/junit-10.xsd"
with fn.open() as f:
return xmlschema.XMLSchema(f)
示例13
def test_qname_decoding(self):
schema = self.schema_class("""<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="rootType" />
<xs:complexType name="rootType">
<xs:simpleContent>
<xs:extension base="xs:QName">
<xs:attribute name="name" type="xs:QName"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:schema>""")
xml_data = '<root xmlns:ns0="http://xmlschema.test/0">ns0:foo</root>'
self.assertEqual(schema.decode(xml_data), 'ns0:foo')
self.assertEqual(schema.decode('<root>foo</root>'), 'foo')
with self.assertRaises(XMLSchemaValidationError) as ctx:
schema.decode('<root>ns0:foo</root>')
self.assertIn("failed validating 'ns0:foo'", str(ctx.exception))
self.assertIn("Reason: unmapped prefix 'ns0' on QName", str(ctx.exception))
self.assertIn("Path: /root", str(ctx.exception))
xml_data = '<root name="ns0:bar" xmlns:ns0="http://xmlschema.test/0">ns0:foo</root>'
self.assertEqual(schema.decode(xml_data), {'@name': 'ns0:bar', '$': 'ns0:foo'})
# Check reverse encoding
obj = schema.decode(xml_data, converter=JsonMLConverter)
root = schema.encode(obj, converter=JsonMLConverter)
self.assertEqual(ElementTree.tostring(root), b'<root name="ns0:bar">ns0:foo</root>\n')
with self.assertRaises(XMLSchemaValidationError) as ctx:
schema.decode('<root name="ns0:bar">foo</root>')
self.assertIn("failed validating 'ns0:bar'", str(ctx.exception))
self.assertIn("Reason: unmapped prefix 'ns0' on QName", str(ctx.exception))
self.assertIn("Path: /root", str(ctx.exception))
示例14
def test_non_global_schema_path(self):
# Issue #157
xs = xmlschema.XMLSchema("""<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:foo="http://example.com/foo"
targetNamespace="http://example.com/foo">
<xs:complexType name="type1">
<xs:sequence>
<xs:element name="sub_part1" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="type2">
<xs:sequence>
<xs:element name="sub_part2" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:element name="foo">
<xs:complexType>
<xs:sequence>
<xs:element name="part1" type="foo:type1" />
<xs:element name="part2" type="foo:type2" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>""")
self.assertEqual(
xs.to_dict(
"""<part1 xmlns:foo="http://example.com/foo">
<sub_part1>test</sub_part1>
</part1>""",
schema_path='.//part1',
),
{"sub_part1": "test"}
)
示例15
def test_dict_granularity(self):
"""Based on Issue #22, test to make sure an xsd indicating list with
dictionaries, returns just that even when it has a single dict. """
xsd_string = self.casepath('issues/issue_022/xsd_string.xsd')
xml_string_1 = self.casepath('issues/issue_022/xml_string_1.xml')
xml_string_2 = self.casepath('issues/issue_022/xml_string_2.xml')
xsd_schema = xmlschema.XMLSchema(xsd_string)
xml_data_1 = xsd_schema.to_dict(xml_string_1)
xml_data_2 = xsd_schema.to_dict(xml_string_2)
self.assertTrue(isinstance(xml_data_1['bar'], type(xml_data_2['bar'])),
msg="XSD with an array that return a single element from "
"xml must still yield a list.")
示例16
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
示例17
def test_cdata_decoding(self):
schema = xmlschema.XMLSchema(self.casepath('issues/issue_046/issue_046.xsd'))
xml_file = self.casepath('issues/issue_046/issue_046.xml')
self.assertEqual(
schema.decode(xml_file, dict_class=ordered_dict_class, cdata_prefix='#'),
ordered_dict_class(
[('@xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance'),
('@xsi:noNamespaceSchemaLocation', 'issue_046.xsd'),
('#1', 'Dear Mr.'), ('name', 'John Smith'),
('#2', '.\n Your order'), ('orderid', 1032),
('#3', 'will be shipped on'), ('shipdate', '2001-07-13'), ('#4', '.')]
))
示例18
def test_default_namespace(self):
# Issue #77
xs = xmlschema.XMLSchema("""<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://example.com/foo">
<xs:element name="foo" type="xs:string" />
</xs:schema>""")
self.assertEqual(xs.to_dict("""<foo xmlns="http://example.com/foo">bar</foo>""",
path='/foo', namespaces={'': 'http://example.com/foo'}), 'bar')
self.assertEqual(xs.to_dict("""<foo>bar</foo>""",
path='/foo', namespaces={'': 'http://example.com/foo'}), None)
示例19
def test_lxml(self):
xs = xmlschema.XMLSchema(self.casepath('examples/vehicles/vehicles.xsd'))
xt1 = lxml_etree.parse(self.casepath('examples/vehicles/vehicles.xml'))
xt2 = lxml_etree.parse(self.casepath('examples/vehicles/vehicles-1_error.xml'))
self.assertTrue(xs.is_valid(xt1))
self.assertFalse(xs.is_valid(xt2))
self.assertTrue(xs.validate(xt1) is None)
self.assertRaises(xmlschema.XMLSchemaValidationError, xs.validate, xt2)
示例20
def test_strip_namespace_argument(self):
# Test for issue #161
converter = XMLSchemaConverter(strip_namespaces=True)
col_xsd_filename = self.casepath('examples/collection/collection.xsd')
col_xml_filename = self.casepath('examples/collection/collection.xml')
col_schema = XMLSchema(col_xsd_filename, converter=converter)
self.assertIn('@xmlns:', str(col_schema.decode(col_xml_filename, strip_namespaces=False)))
self.assertNotIn('@xmlns:', str(col_schema.decode(col_xml_filename)))
示例21
def build_schema(source):
xs = xmlschema.XMLSchema(source)
return xs
示例22
def lazy_decode(source, repeat=1):
decoder = xmlschema.XMLSchema.meta_schema if source.endswith('.xsd') else xmlschema
for _ in range(repeat):
for result in decoder.to_dict(xmlschema.XMLResource(source, lazy=True), path='*'):
del result
示例23
def validate(source, repeat=1):
validator = xmlschema.XMLSchema.meta_schema if source.endswith('.xsd') else xmlschema
for _ in range(repeat):
validator.validate(source)
示例24
def lazy_validate(source, repeat=1):
if source.endswith('.xsd'):
validator, path = xmlschema.XMLSchema.meta_schema, '*'
else:
validator, path = xmlschema, None
for _ in range(repeat):
validator.validate(xmlschema.XMLResource(source, lazy=True), path=path)
示例25
def __init__(self, xsd, elem, enable_choice):
self.xsd = xmlschema.XMLSchema(xsd)
self.elem = elem
self.enable_choice = enable_choice
self.root = True
self.vals = {}
# shorten the namespace
示例26
def validate_single_file(file_to_test: ConnectorFile, path_to_file: Path, xml_violations_buffer: List[str]) -> bool:
"""
Arguments:
file_to_test {ConnectorFile} -- path to a single file to test
path_to_file {Path} -- path to the file
xml_violations_buffer {list[str]} -- a list of strings that holds the xml violation messages
Returns:
bool -- True if the xml file passes validation, false if it does not or there is an error
Any xml violation messages will be appended to xml_violations_buffer
"""
logger.debug("Validating " + str(path_to_file))
xsd_file = get_xsd_file(file_to_test)
if not xsd_file:
xml_violations_buffer.append("Error: No valid XSD for file type:" + file_to_test.file_type)
return False
manifest_schema = XMLSchema(str(PATH_TO_XSD_FILES / Path(xsd_file)))
saved_error = None
# If the file is too big, we shouldn't try and parse it, just log the violation and move on
if path_to_file.stat().st_size > MAX_FILE_SIZE:
xml_violations_buffer.append(file_to_test.file_name + " exceeds maximum size of " +
str(int(MAX_FILE_SIZE / 1024)) + " KB")
return False
# Try to validate the xml. If the xml validation error is thrown, save the violation information to the buffer
try:
manifest_schema.validate(str(path_to_file))
except Exception:
saved_error_type = sys.exc_info()[0]
saved_error = sys.exc_info()[1]
xml_violations_buffer.append("File: " + file_to_test.file_name + " Error Type: " + str(saved_error_type) +
"\n" + str(saved_error))
logger.error("XML Validation failed for " + file_to_test.file_name)
return False
if not validate_file_specific_rules(file_to_test, path_to_file, xml_violations_buffer):
logger.error("XML Validation failed for " + file_to_test.file_name)
return False
return True
# Return the XSD file to test against
示例27
def test_date_decoding(self):
# Issue #136
schema = xmlschema.XMLSchema("""<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" version="1.0">
<xs:element name="Date">
<xs:simpleType>
<xs:restriction base="xs:date">
<xs:minInclusive value="2000-01-01"/>
<xs:maxInclusive value="2099-12-31"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
</xs:schema>""")
self.assertEqual(schema.to_dict("<Date>2019-01-01</Date>"), '2019-01-01')
self.assertEqual(schema.to_dict("<Date>2019-01-01</Date>", datetime_types=True),
datatypes.Date10.fromstring('2019-01-01'))
data, errors = schema.to_dict("<Date>2019-01-01</Date>", validation='lax')
self.assertEqual(data, '2019-01-01')
self.assertEqual(errors, [])
data, errors = schema.to_dict("<Date>2019-01-01</Date>", validation='lax',
datetime_types=True)
self.assertEqual(data, datatypes.Date10.fromstring('2019-01-01'))
self.assertEqual(errors, [])
data, errors = schema.to_dict("<Date>1999-12-31</Date>", validation='lax')
self.assertEqual(data, '1999-12-31')
self.assertEqual(len(errors), 1)
self.assertIn('value has to be greater or equal than', str(errors[0]))
data, errors = schema.to_dict("<Date>1999-12-31</Date>", validation='lax',
datetime_types=True)
self.assertEqual(data, datatypes.Date10.fromstring('1999-12-31'))
self.assertEqual(len(errors), 1)
data, errors = schema.to_dict("<Date>2019</Date>", validation='lax')
self.assertIsNone(data)
self.assertEqual(len(errors), 1)
with self.assertRaises(XMLSchemaValidationError):
schema.to_dict("<Date>2019</Date>")
data, errors = schema.to_dict("<Date>2019</Date>", validation='lax')
self.assertIsNone(data)
self.assertEqual(len(errors), 1)
示例28
def test_default_values(self):
# From issue #108
xsd_text = """<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="root" default="default_value"/>
<xs:complexType name="root">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="attr" type="xs:string"/>
<xs:attribute name="attrWithDefault" type="xs:string" default="default_value"/>
<xs:attribute name="attrWithFixed" type="xs:string" fixed="fixed_value"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:element name="simple_root" type="xs:string" default="default_value"/>
</xs:schema>"""
schema = self.schema_class(xsd_text)
self.assertEqual(schema.to_dict("<root>text</root>"),
{'@attrWithDefault': 'default_value',
'@attrWithFixed': 'fixed_value',
'$': 'text'})
self.assertEqual(schema.to_dict("<root/>"),
{'@attrWithDefault': 'default_value',
'@attrWithFixed': 'fixed_value',
'$': 'default_value'})
self.assertEqual(schema.to_dict("""<root attr="attr_value">text</root>"""),
{'$': 'text',
'@attr': 'attr_value',
'@attrWithDefault': 'default_value',
'@attrWithFixed': 'fixed_value'})
self.assertEqual(schema.to_dict("<root>text</root>", use_defaults=False),
{'@attrWithFixed': 'fixed_value', '$': 'text'})
self.assertEqual(schema.to_dict("""<root attr="attr_value">text</root>""",
use_defaults=False),
{'$': 'text', '@attr': 'attr_value', '@attrWithFixed': 'fixed_value'})
self.assertEqual(schema.to_dict("<root/>", use_defaults=False),
{'@attrWithFixed': 'fixed_value'})
self.assertEqual(schema.to_dict("<simple_root/>"), 'default_value')
self.assertIsNone(schema.to_dict("<simple_root/>", use_defaults=False))
示例29
def test_issue_183(self):
# Test for issue #183
schema = self.schema_class("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:tns0="http://xmlschema.test/0"
xmlns:tns1="http://xmlschema.test/1"
xmlns="http://xmlschema.test/2"
targetNamespace="http://xmlschema.test/0">
<xs:element name="elem1" type="xs:string"/>
<xs:element name="elem2" type="xs:string"/>
<xs:element name="root" type="tns0:enumType"/>
<xs:simpleType name="enumType">
<xs:restriction base="xs:QName">
<xs:enumeration value="tns0:elem1"/>
<xs:enumeration value="tns0:elem2"/>
<xs:enumeration value="tns1:elem1"/>
<xs:enumeration value="elem1"/>
</xs:restriction>
</xs:simpleType>
</xs:schema>""")
xml_data = '<tns0:root xmlns:tns0="http://xmlschema.test/0" >tns0:elem1</tns0:root>'
self.check_validity(schema, xml_data, True)
xml_data = '<ns0:root xmlns:ns0="http://xmlschema.test/0" >ns0:elem1</ns0:root>'
self.check_validity(schema, xml_data, True)
self.assertEqual(schema.decode(xml_data), 'ns0:elem1')
schema = self.schema_class("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://xmlschema.test/0"
xmlns:tns1="http://xmlschema.test/1"
xmlns:tns2="http://xmlschema.test/2"
targetNamespace="http://xmlschema.test/0">
<xs:element name="elem1" type="xs:string"/>
<xs:element name="elem2" type="xs:string"/>
<xs:element name="elem3" type="xs:string"/>
<xs:element name="elem4" type="xs:string"/>
<xs:element name="root" type="enumType"/>
<xs:simpleType name="enumType">
<xs:restriction base="xs:QName">
<xs:enumeration value="elem1"/>
<xs:enumeration value="elem2"/>
<xs:enumeration value="tns1:other1"/>
<xs:enumeration value="elem3"/>
<xs:enumeration value="tns2:other2"/>
<xs:enumeration value="elem4"/>
</xs:restriction>
</xs:simpleType>
</xs:schema>""")
xml_data = '<ns0:root xmlns:ns0="http://xmlschema.test/0">ns0:elem2</ns0:root>'
self.check_validity(schema, xml_data, True)
示例30
def test_exception_repr(self):
xs = XMLSchema(os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd'))
error = XMLSchemaValidatorError(xs, 'unknown error')
self.assertEqual(str(error), 'unknown error')
self.assertEqual(error.msg, 'unknown error')
error = XMLSchemaValidatorError(xs, 'unknown error', elem=xs.root)
lines = str(error).split('\n')
self.assertEqual(lines[0], 'unknown error:')
self.assertEqual(lines[2], 'Schema:')
self.assertTrue(lines[4].strip().startswith('<xs:schema '))
self.assertEqual(lines[-2].strip(), '</xs:schema>')
schema = XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="xs:integer"/>
</xs:schema>""")
root = lxml.etree.XML('<root a="10"/>')
with self.assertRaises(XMLSchemaValidationError) as ctx:
schema.validate(root)
lines = str(ctx.exception).split('\n')
self.assertEqual(lines[0], "failed validating {'a': '10'} with XsdAttributeGroup():")
self.assertEqual(lines[2], "Reason: 'a' attribute not allowed for element.")
self.assertEqual(lines[8], "Instance (line 1):")
self.assertEqual(lines[12], "Path: /root")
self.assertEqual(repr(ctx.exception), "XMLSchemaValidationError(reason=\"'a' "
"attribute not allowed for element.\")")
error = XMLSchemaValidationError(schema.elements['root'], root)
self.assertIsNone(error.reason)
self.assertNotIn("Reason:", str(error))
self.assertIn("Schema:", str(error))
error = XMLSchemaValidationError(schema, root)
self.assertNotIn("Reason:", str(error))
self.assertNotIn("Schema:", str(error))
error = XMLSchemaValidationError(schema, 10)
self.assertEqual(str(error), "failed validating 10 with XMLSchema10(namespace='')")
