#!/usr/bin/env python # # Copyright (c), 2016-2020, SISSA (International School for Advanced Studies). # All rights reserved. # This file is distributed under the terms of the MIT License. # See the file 'LICENSE' in the root directory of the present # distribution, or http://opensource.org/licenses/MIT. # # @author Davide Brunato # import unittest import os import platform import re import lxml.etree from xmlschema.validators import XsdValidator, XsdComponent, XMLSchema10, \ XMLSchema11, XMLSchemaParseError, XMLSchemaValidationError, XsdGroup, XsdSimpleType from xmlschema.names import XSD_NAMESPACE, XSD_ELEMENT, XSD_ANNOTATION, XSD_ANY_TYPE from xmlschema.etree import ElementTree CASES_DIR = os.path.join(os.path.dirname(__file__), '../test_cases') class TestXsdValidator(unittest.TestCase): def test_initialization(self): validator = XsdValidator() self.assertEqual(validator.validation, 'strict') validator = XsdValidator(validation='lax') self.assertEqual(validator.validation, 'lax') self.assertListEqual(validator.errors, []) def test_string_representation(self): validator = XsdValidator() tmpl = '' string_repr = str(validator) if platform.python_implementation() == 'PyPy' or platform.system() == 'Windows': string_repr = re.sub(r'0x[0]+', '0x', string_repr, 1) self.assertEqual(string_repr.lower(), tmpl.format(hex(id(validator))).lower()) def test_parse_error(self): xsd_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd') schema = XMLSchema10(xsd_file) with self.assertRaises(TypeError): schema.parse_error("test error", elem=(1, 2)) with self.assertRaises(TypeError): schema.parse_error(b"test error") with self.assertRaises(XMLSchemaParseError): schema.parse_error("test error") self.assertEqual(len(schema.errors), 0) schema.parse_error("test error", validation='skip') self.assertEqual(len(schema.errors), 0) schema.parse_error("test error", validation='lax') self.assertEqual(len(schema.errors), 1) schema.parse_error(XMLSchemaParseError(schema, "test error"), validation='lax') self.assertEqual(len(schema.errors), 2) schema.parse_error(ValueError("wrong value"), validation='lax') self.assertEqual(len(schema.errors), 3) schema.parse_error(ValueError("'invalid value'"), validation='lax') self.assertEqual(len(schema.errors), 4) self.assertEqual(schema.errors[-1].message, "invalid value") def test_copy(self): validator = XsdValidator(validation='lax') validator.parse_error(ValueError("test error")) self.assertEqual(len(validator.errors), 1) self.assertListEqual(validator.copy().errors, validator.errors) def test_valid_schema(self): xsd_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd') schema = XMLSchema10(xsd_file, build=False) self.assertEqual(schema.validity, 'notKnown') self.assertEqual(len(schema.all_errors), 0) schema.build() self.assertEqual(schema.validity, 'valid') self.assertEqual(len(schema.all_errors), 0) def test_invalid_schema(self): xsd_text = """ """ with self.assertRaises(XMLSchemaParseError): XMLSchema10(xsd_text) schema = XMLSchema10(xsd_text, validation='lax') self.assertEqual(schema.validity, 'invalid') self.assertEqual(len(schema.all_errors), 2) # One by meta-schema check schema = XMLSchema10(xsd_text, validation='skip') self.assertEqual(schema.validity, 'notKnown') self.assertEqual(len(schema.all_errors), 0) def test_parse_xpath_default_namespace(self): xsd_text = """ """ 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 = """ """ 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) class TestXsdComponent(unittest.TestCase): class FakeElement(XsdComponent): @property def built(self): return super().built _ADMITTED_TAGS = (XSD_ELEMENT,) @classmethod def setUpClass(cls): xsd_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd') cls.schema = XMLSchema10(xsd_file) 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) def test_is_override(self): self.assertFalse(self.schema.elements['cars'].is_override()) self.assertFalse(self.schema.elements['cars'].type.content[0].is_override()) def test_representation(self): schema = XMLSchema10(""" """) self.assertEqual(repr(schema.elements['node']), "XsdElement(name='node', occurs=[1, 1])") self.assertEqual(repr(schema.attributes['slot']), "XsdAttribute(name='slot')") self.assertEqual(repr(schema.elements['node'].type.attributes['slot']), "XsdAttribute(ref='slot')") 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_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) self.assertEqual(len(xsd_element.errors), 0) xsd_element.validation = 'lax' xsd_element._parse_child_component(elem) self.assertEqual(len(xsd_element.errors), 1) 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(""" """) self.assertIn("use of attribute 'targetNamespace' is prohibited", ctx.exception.message) schema = XMLSchema11(""" """) self.assertEqual(schema.elements['root'].type.content[0].target_namespace, 'http://xmlschema.test/ns') schema = XMLSchema11(""" """) self.assertEqual(schema.elements['root'].type.content[0].name, 'node') 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_validation_attempted(self): schema = XMLSchema10(""" """) self.assertEqual(schema.notations['content'].validation_attempted, 'full') 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_get_global(self): xsd_element = self.schema.elements['vehicles'] self.assertIs(xsd_element.get_global(), xsd_element) xsd_type = self.schema.types['vehicleType'] self.assertIs(xsd_type.attributes['model'].get_global(), xsd_type) def test_get_parent_type(self): xsd_type = self.schema.types['vehicleType'] self.assertIs(xsd_type.attributes['model'].get_parent_type(), xsd_type) self.assertIsNone(xsd_type.get_parent_type()) 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_iter_ancestors(self): xsd_element = self.schema.elements['cars'].type.content[0] ancestors = [e for e in xsd_element.iter_ancestors()] self.assertListEqual(ancestors, [ self.schema.elements['cars'].type.content, self.schema.elements['cars'].type, self.schema.elements['cars'], ]) self.assertListEqual(list(xsd_element.iter_ancestors(str)), []) def test_tostring(self): cars_dump = str(self.schema.elements['cars'].tostring()) self.assertEqual(len(cars_dump.split('\n')), 7) self.assertIn('name="car" type="vh:vehicleType"', cars_dump) self.assertIsInstance(ElementTree.XML(cars_dump), ElementTree.Element) def test_annotation(self): schema = XMLSchema10(""" """) self.assertTrue(schema.elements['root'].annotation.built) root = lxml.etree.XML(""" """) schema = XMLSchema10(root) self.assertTrue(schema.elements['root'].annotation.built) schema = XMLSchema10(""" """) self.assertEqual(len(schema.all_errors), 0) schema = XMLSchema10(""" """, validation='lax') self.assertEqual(len(schema.all_errors), 3) class TestXsdType(unittest.TestCase): @classmethod def setUpClass(cls): cls.schema = XMLSchema10(""" """) def test_content_type_label(self): self.assertEqual(self.schema.types['emptyType'].content_type_label, 'empty') self.assertEqual(self.schema.types['emptyType2'].content_type_label, 'empty') self.assertEqual(self.schema.types['fooType'].content_type_label, 'simple') self.assertEqual(self.schema.types['barType'].content_type_label, 'element-only') self.assertEqual(self.schema.types['mixedType'].content_type_label, 'mixed') def test_simple_type_property(self): self.assertIsInstance(self.schema.types['emptyType'].simple_type, XsdSimpleType) self.assertIsNone(self.schema.types['emptyType2'].simple_type) def test_model_group_property(self): self.assertIsNone(self.schema.types['emptyType'].model_group) self.assertIsInstance(self.schema.types['emptyType2'].model_group, XsdGroup) def test_root_type(self): self.assertIs(self.schema.types['fooType'].root_type, self.schema.meta_schema.types['string']) self.assertIs(self.schema.types['fooListType'].root_type, self.schema.meta_schema.types['string']) self.assertIs(self.schema.types['mixedType'].root_type, self.schema.maps.types[XSD_ANY_TYPE]) self.assertIs(self.schema.types['barExtType'].root_type, self.schema.maps.types[XSD_ANY_TYPE]) def test_is_atomic(self): self.assertFalse(self.schema.types['barType'].is_atomic()) def test_is_list(self): self.assertFalse(self.schema.types['barType'].is_list()) self.assertTrue(self.schema.types['fooListType'].is_list()) self.assertFalse(self.schema.types['fooUnionType'].is_list()) def test_is_union(self): self.assertFalse(self.schema.types['barType'].is_union()) self.assertFalse(self.schema.types['fooListType'].is_union()) self.assertTrue(self.schema.types['fooUnionType'].is_union()) def test_is_datetime(self): self.assertFalse(self.schema.types['barType'].is_datetime()) self.assertTrue(self.schema.types['dateTimeType'].is_datetime()) def test_is_decimal(self): self.assertFalse(self.schema.types['barType'].is_decimal()) self.assertTrue(self.schema.types['decimalType'].is_decimal()) def test_is_dynamic_consistent(self): self.assertFalse(self.schema.types['fooType'].is_dynamic_consistent( self.schema.types['fooListType'] )) self.assertTrue(self.schema.types['fooType'].is_dynamic_consistent( self.schema.types['fooType'] )) def test_is_key(self): self.assertFalse(self.schema.types['fooType'].is_key()) self.assertTrue(self.schema.types['idType'].is_key()) def test_is_extension(self): self.assertFalse(self.schema.types['fooType'].is_extension()) self.assertTrue(self.schema.types['barExtType'].is_extension()) def test_is_restriction(self): self.assertTrue(self.schema.types['fooType'].is_restriction()) self.assertFalse(self.schema.types['barExtType'].is_restriction()) def test_is_blocked(self): element = self.schema.elements['fooElem'] self.assertFalse(self.schema.types['fooType'].is_blocked(element)) self.assertFalse(self.schema.types['barExtType'].is_blocked(element)) self.assertFalse(self.schema.types['barResType'].is_blocked(element)) element = self.schema.elements['barElem'] self.assertFalse(self.schema.types['fooType'].is_blocked(element)) self.assertTrue(self.schema.types['barExtType'].is_blocked(element)) self.assertFalse(self.schema.types['barResType'].is_blocked(element)) class TestValidationMixin(unittest.TestCase): @classmethod def setUpClass(cls): xsd_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd') cls.schema = XMLSchema10(xsd_file) def test_validate(self): xml_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xml') root = ElementTree.parse(xml_file).getroot() self.assertIsNone(self.schema.elements['vehicles'].validate(root)) xml_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles-1_error.xml') root = ElementTree.parse(xml_file).getroot() with self.assertRaises(XMLSchemaValidationError): self.schema.elements['vehicles'].validate(root) def test_decode(self): xml_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xml') root = ElementTree.parse(xml_file).getroot() obj = self.schema.elements['vehicles'].decode(root) self.assertIsInstance(obj, dict) self.assertIn(self.schema.elements['cars'].name, obj) self.assertIn(self.schema.elements['bikes'].name, obj) xml_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles-2_errors.xml') root = ElementTree.parse(xml_file).getroot() obj, errors = self.schema.elements['vehicles'].decode(root, validation='lax') self.assertIsInstance(obj, dict) self.assertIn(self.schema.elements['cars'].name, obj) self.assertIn(self.schema.elements['bikes'].name, obj) self.assertEqual(len(errors), 2) def test_encode(self): xml_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xml') obj = self.schema.decode(xml_file) root = self.schema.elements['vehicles'].encode(obj) self.assertEqual(root.tag, self.schema.elements['vehicles'].name) xml_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles-2_errors.xml') obj, errors = self.schema.decode(xml_file, validation='lax') root, errors2 = self.schema.elements['vehicles'].encode(obj, validation='lax') self.assertEqual(root.tag, self.schema.elements['vehicles'].name) def test_validation_error(self): elem = ElementTree.XML('') with self.assertRaises(XMLSchemaValidationError): self.schema.validation_error('strict', 'Test error', obj=elem) self.assertIsInstance(self.schema.validation_error('lax', 'Test error'), XMLSchemaValidationError) self.assertIsInstance(self.schema.validation_error('lax', 'Test error'), XMLSchemaValidationError) self.assertIsInstance(self.schema.validation_error('skip', 'Test error'), XMLSchemaValidationError) error = self.schema.validation_error('lax', 'Test error') self.assertIsNone(error.obj) self.assertEqual(self.schema.validation_error('lax', error, obj=10).obj, 10) if __name__ == '__main__': header_template = "Test xmlschema's XSD base classes with Python {} on {}" header = header_template.format(platform.python_version(), platform.platform()) print('{0}\n{1}\n{0}'.format("*" * len(header), header)) unittest.main()