def setUpClass(cls):
cls.schema = XMLSchema10(XSD_TEST)
cls.searchpath = Path(__file__).absolute().parent.joinpath(
'templates/filters/')
cls.generator = cls.generator_class(cls.schema, str(cls.searchpath))
cls.col_dir = casepath('examples/collection')
cls.col_xsd_file = casepath('examples/collection/collection.xsd')
cls.col_xml_file = casepath('examples/collection/collection.xml')
cls.col_schema = XMLSchema10(cls.col_xsd_file)
def test_from_json_api(self):
json_data = to_json(self.col_xml_file, lazy=True)
with self.assertRaises(TypeError) as ctx:
from_json(json_data, self.col_xsd_file)
self.assertIn("invalid type <class 'str'> for argument 'schema'",
str(ctx.exception))
col_schema = XMLSchema10(self.col_xsd_file)
collection = from_json(json_data, schema=col_schema)
self.assertEqual(collection.tag,
'{http://example.com/ns/collection}collection')
col_schema = XMLSchema10(self.col_xsd_file)
collection = from_json(json_data,
col_schema,
json_options={'parse_float': Decimal})
self.assertEqual(collection.tag,
'{http://example.com/ns/collection}collection')
def test_xml_document_decode_with_schema(self):
xml_document = XmlDocument(self.vh_xml_file)
vh_schema = XMLSchema10(self.vh_xsd_file)
self.assertEqual(xml_document.decode(),
vh_schema.decode(self.vh_xml_file))
namespaces = {'vh': 'http://example.com/ns'}
self.assertEqual(
xml_document.decode(namespaces=namespaces),
vh_schema.decode(self.vh_xml_file, namespaces=namespaces))
self.assertNotEqual(xml_document.decode(namespaces=namespaces),
vh_schema.decode(self.vh_xml_file))
xml_file = casepath('examples/collection/collection-1_error.xml')
xml_document = XmlDocument(xml_file, validation='lax')
col_schema = XMLSchema10(self.col_xsd_file)
self.assertEqual(xml_document.decode(),
col_schema.decode(xml_file, validation='lax')[0])
xml_document = XmlDocument(xml_file, validation='skip')
self.assertEqual(xml_document.decode(),
col_schema.decode(xml_file, validation='skip'))
self.assertEqual(xml_document.decode(validation='lax'),
col_schema.decode(xml_file, validation='lax')[0])
def test_get_context_with_schema(self):
source, schema = get_context(self.col_xml_file)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema10)
source, schema = get_context(self.col_xml_file, self.col_xsd_file)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema10)
col_schema = XMLSchema10(self.col_xsd_file)
source, schema = get_context(self.col_xml_file, col_schema)
self.assertIsInstance(source, XMLResource)
self.assertIs(schema, col_schema)
source, schema = get_context(self.vh_xml_file, cls=XMLSchema10)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema10)
source, schema = get_context(self.col_xml_file, cls=XMLSchema11)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema11)
source, schema = get_context(XMLResource(self.vh_xml_file))
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema10)
xml_document = XmlDocument(self.vh_xml_file)
source, schema = get_context(xml_document)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema10)
self.assertIs(xml_document.schema, schema)
# Issue #145
with open(self.vh_xml_file) as f:
source, schema = get_context(f, schema=self.vh_xsd_file)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema10)
with open(self.vh_xml_file) as f:
source, schema = get_context(XMLResource(f),
schema=self.vh_xsd_file)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema10)
with open(self.vh_xml_file) as f:
source, schema = get_context(f, base_url=self.vh_dir)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema10)
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_xml_document_write(self):
with tempfile.TemporaryDirectory() as dirname:
col_file_path = pathlib.Path(dirname).joinpath('collection.xml')
xml_document = XmlDocument(self.col_xml_file)
xml_document.write(col_file_path.open(mode='wb'))
schema = XMLSchema10(self.col_xsd_file)
xml_document = XmlDocument(str(col_file_path), schema=schema)
self.assertEqual(xml_document.root.tag,
'{http://example.com/ns/collection}collection')
self.assertIs(xml_document.schema, schema)
col_file_path.unlink()
xml_document.write(str(col_file_path))
xml_document = XmlDocument(str(col_file_path), schema=schema)
self.assertIs(xml_document.schema, schema)
col_file_path.unlink()
xml_document.write(str(col_file_path), encoding='unicode')
xml_document = XmlDocument(str(col_file_path), schema=schema)
self.assertIs(xml_document.schema, schema)
col_file_path.unlink()
xml_document.write(
str(col_file_path),
default_namespace="http://example.com/ns/collection")
xml_document = XmlDocument(str(col_file_path), schema=schema)
self.assertIs(xml_document.schema, schema)
if lxml_etree is not None:
col_file_path.unlink()
col_etree_document = lxml_etree.parse(self.col_xml_file)
xml_document = XmlDocument(col_etree_document,
base_url=self.col_dir)
xml_document.write(
str(col_file_path),
default_namespace="http://example.com/ns/collection")
xml_document = XmlDocument(str(col_file_path), schema=schema)
self.assertIs(xml_document.schema, schema)
col_file_path.unlink()
xml_document = XmlDocument(self.col_xml_file, lazy=True)
with self.assertRaises(XMLResourceError) as ctx:
xml_document.write(str(col_file_path))
self.assertEqual(str(ctx.exception),
"cannot serialize a lazy XML document")
def test_get_context_without_schema(self):
xml_data = '<text xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"\n' \
' xmlns:xs="http://www.w3.org/2001/XMLSchema"\n' \
' xsi:type="xs:string">foo</text>'
source, schema = get_context(xml_data)
self.assertIsInstance(source, XMLResource)
self.assertIs(schema, XMLSchema10.meta_schema)
self.assertEqual(source.root.tag, 'text')
self.assertTrue(schema.is_valid(source))
with self.assertRaises(ValueError) as ctx:
get_context('<empty/>')
self.assertEqual(
str(ctx.exception),
"no schema can be retrieved for the provided XML data")
source, schema = get_context('<empty/>', dummy_schema=True)
self.assertEqual(source.root.tag, 'empty')
self.assertIsInstance(schema, XMLSchema10)
col_xml_resource = XMLResource(self.col_xml_file)
col_xml_resource.root.attrib.clear()
self.assertEqual(col_xml_resource.get_locations(), [])
source, schema = get_context(col_xml_resource, self.col_xsd_file)
self.assertIs(source, col_xml_resource)
self.assertIsInstance(schema, XMLSchema10)
self.assertEqual(schema.target_namespace,
'http://example.com/ns/collection')
# Schema target namespace doesn't match source namespace
vh_schema = XMLSchema10(self.vh_xsd_file)
source, schema = get_context(col_xml_resource, vh_schema)
self.assertIs(source, col_xml_resource)
self.assertIs(schema, vh_schema)
self.assertFalse(schema.is_valid(source))
vh_schema.import_schema('http://example.com/ns/collection',
self.col_xsd_file)
vh_schema.build()
source, schema = get_context(col_xml_resource, vh_schema)
self.assertIs(source, col_xml_resource)
self.assertIs(schema, vh_schema)
self.assertTrue(schema.is_valid(source))
def test_has_occurs_restriction(self):
schema = XMLSchema10(
"""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="barType">
<xs:sequence>
<xs:element name="node0" />
<xs:element name="node1" minOccurs="0"/>
<xs:element name="node2" minOccurs="0" maxOccurs="unbounded"/>
<xs:element name="node3" minOccurs="2" maxOccurs="unbounded"/>
<xs:element name="node4" minOccurs="2" maxOccurs="10"/>
<xs:element name="node5" minOccurs="4" maxOccurs="10"/>
<xs:element name="node6" minOccurs="4" maxOccurs="9"/>
<xs:element name="node7" minOccurs="1" maxOccurs="9"/>
<xs:element name="node8" minOccurs="3" maxOccurs="11"/>
<xs:element name="node9" minOccurs="0" maxOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:schema>""")
xsd_group = schema.types['barType'].content
for k in range(9):
self.assertTrue(xsd_group[k].has_occurs_restriction(xsd_group[k]),
msg="Fail for node%d" % k)
self.assertTrue(xsd_group[0].has_occurs_restriction(xsd_group[1]))
self.assertFalse(xsd_group[1].has_occurs_restriction(xsd_group[0]))
self.assertTrue(xsd_group[3].has_occurs_restriction(xsd_group[2]))
self.assertFalse(xsd_group[2].has_occurs_restriction(xsd_group[1]))
self.assertFalse(xsd_group[2].has_occurs_restriction(xsd_group[3]))
self.assertTrue(xsd_group[4].has_occurs_restriction(xsd_group[3]))
self.assertTrue(xsd_group[4].has_occurs_restriction(xsd_group[2]))
self.assertFalse(xsd_group[4].has_occurs_restriction(xsd_group[5]))
self.assertTrue(xsd_group[5].has_occurs_restriction(xsd_group[4]))
self.assertTrue(xsd_group[6].has_occurs_restriction(xsd_group[5]))
self.assertFalse(xsd_group[5].has_occurs_restriction(xsd_group[6]))
self.assertFalse(xsd_group[7].has_occurs_restriction(xsd_group[6]))
self.assertFalse(xsd_group[5].has_occurs_restriction(xsd_group[7]))
self.assertTrue(xsd_group[6].has_occurs_restriction(xsd_group[7]))
self.assertFalse(xsd_group[7].has_occurs_restriction(xsd_group[8]))
self.assertFalse(xsd_group[8].has_occurs_restriction(xsd_group[7]))
self.assertTrue(xsd_group[9].has_occurs_restriction(xsd_group[1]))
self.assertTrue(xsd_group[9].has_occurs_restriction(xsd_group[2]))
def test_xml_document_init_with_schema(self):
xml_document = XmlDocument(self.vh_xml_file)
self.assertEqual(os.path.basename(xml_document.url), 'vehicles.xml')
self.assertEqual(xml_document.errors, ())
self.assertIsInstance(xml_document.schema, XMLSchema10)
xml_document = XmlDocument(self.vh_xml_file, cls=XMLSchema11)
self.assertIsInstance(xml_document.schema, XMLSchema11)
xml_document = XmlDocument(self.vh_xml_file, self.vh_xsd_file)
self.assertIsInstance(xml_document.schema, XMLSchema10)
vh_schema = XMLSchema10(self.vh_xsd_file)
xml_document = XmlDocument(self.vh_xml_file, vh_schema)
self.assertIsInstance(xml_document.schema, XMLSchema10)
with self.assertRaises(XMLSchemaValidationError) as ctx:
XmlDocument(self.vh_xml_file, self.col_xsd_file)
self.assertIn('is not an element of the schema', str(ctx.exception))
xml_document = XmlDocument(self.col_xml_file)
self.assertEqual(os.path.basename(xml_document.url), 'collection.xml')
self.assertIsInstance(xml_document.schema, XMLSchema10)
xml_file = casepath('examples/collection/collection-1_error.xml')
with self.assertRaises(XMLSchemaValidationError) as ctx:
XmlDocument(xml_file)
self.assertIn('invalid literal for int() with base 10',
str(ctx.exception))
xml_document = XmlDocument(xml_file, validation='lax')
self.assertEqual(os.path.basename(xml_document.url),
'collection-1_error.xml')
self.assertIsInstance(xml_document.schema, XMLSchema10)
self.assertTrue(len(xml_document.errors), 1)
with self.assertRaises(ValueError) as ctx:
XmlDocument(xml_file, validation='foo')
self.assertEqual(str(ctx.exception), "'foo': not a validation mode")
def setUpClass(cls):
xsd_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd')
cls.schema = XMLSchema10(xsd_file)
def setUpClass(cls):
cls.types = XMLSchema10.builtin_types()