def test_xml_resource_defuse(self):
resource = XMLResource(self.vh_xml_file, defuse='never')
self.assertEqual(resource.defuse, 'never')
self.assertRaises(ValueError,
XMLResource,
self.vh_xml_file,
defuse='all')
self.assertRaises(ValueError,
XMLResource,
self.vh_xml_file,
defuse=None)
self.assertIsInstance(resource.root, etree_element)
resource = XMLResource(self.vh_xml_file, defuse='always')
self.assertIsInstance(resource.root, py_etree_element)
xml_file = casepath('resources/with_entity.xml')
self.assertIsInstance(XMLResource(xml_file), XMLResource)
self.assertRaises(PyElementTree.ParseError,
XMLResource,
xml_file,
defuse='always')
xml_file = casepath('resources/unused_external_entity.xml')
self.assertIsInstance(XMLResource(xml_file), XMLResource)
self.assertRaises(PyElementTree.ParseError,
XMLResource,
xml_file,
defuse='always')
xml_file = casepath('resources/external_entity.xml')
self.assertIsInstance(XMLResource(xml_file), XMLResource)
self.assertRaises(PyElementTree.ParseError,
XMLResource,
xml_file,
defuse='always')
def test_xml_resource_from_file(self):
with open(self.vh_schema_file) as schema_file:
resource = XMLResource(schema_file)
self.assertEqual(resource.source, schema_file)
self.assertEqual(resource.root.tag,
'{http://www.w3.org/2001/XMLSchema}schema')
self.assertEqual(resource.url.lower(),
FILE_SCHEME.format(self.vh_schema_file).lower())
self.assertIsNone(resource.document)
self.assertIsNone(resource.text)
resource.load()
self.assertTrue(resource.text.startswith('<xs:schema'))
with open(self.vh_schema_file) as schema_file:
resource = XMLResource(schema_file, lazy=False)
self.assertEqual(resource.source, schema_file)
self.assertEqual(resource.root.tag,
'{http://www.w3.org/2001/XMLSchema}schema')
if not IS_WIN_PLATFORM:
self.assertEqual(resource.url,
FILE_SCHEME.format(self.vh_schema_file))
self.assertIsInstance(resource.document, ElementTree.ElementTree)
self.assertIsNone(resource.text)
resource.load()
self.assertTrue(resource.text.startswith('<xs:schema'))
def test_xml_resource_iter(self):
resource = XMLResource(self.schema_class.meta_schema.source.url,
lazy=False)
self.assertFalse(resource.is_lazy())
lazy_resource = XMLResource(self.schema_class.meta_schema.source.url)
self.assertTrue(lazy_resource.is_lazy())
tags = [x.tag for x in resource.iter()]
self.assertEqual(len(tags), 1390)
self.assertEqual(tags[0], '{%s}schema' % XSD_NAMESPACE)
lazy_tags = [x.tag for x in lazy_resource.iter()]
self.assertEqual(len(lazy_tags), 1390)
self.assertEqual(lazy_tags[-1], '{%s}schema' % XSD_NAMESPACE)
self.assertNotEqual(tags, lazy_tags)
tags = [
x.tag for x in resource.iter('{%s}complexType' % XSD_NAMESPACE)
]
self.assertEqual(len(tags), 56)
self.assertEqual(tags[0], '{%s}complexType' % XSD_NAMESPACE)
self.assertListEqual(tags, [
x.tag
for x in lazy_resource.iter('{%s}complexType' % XSD_NAMESPACE)
])
def test_xml_resource_open(self):
resource = XMLResource(self.vh_xml_file)
xml_file = resource.open()
data = xml_file.read().decode('utf-8')
self.assertTrue(data.startswith('<?xml '))
xml_file.close()
resource = XMLResource('<A/>')
self.assertRaises(ValueError, resource.open)
def test_xml_resource_seek(self):
resource = XMLResource(self.vh_xml_file)
self.assertIsNone(resource.seek(0))
self.assertIsNone(resource.seek(1))
xml_file = open(self.vh_xml_file)
resource = XMLResource(source=xml_file)
self.assertEqual(resource.seek(0), 0)
self.assertEqual(resource.seek(1), 1)
xml_file.close()
def test_xml_resource_namespace(self):
resource = XMLResource(self.vh_xml_file)
self.assertEqual(resource.namespace, 'http://example.com/vehicles')
resource = XMLResource(self.vh_xsd_file)
self.assertEqual(resource.namespace,
'http://www.w3.org/2001/XMLSchema')
resource = XMLResource(self.col_xml_file)
self.assertEqual(resource.namespace,
'http://example.com/ns/collection')
self.assertEqual(XMLResource('<A/>').namespace, '')
def test_xml_resource_access(self):
resource = XMLResource(self.vh_xml_file)
base_url = resource.base_url
XMLResource(self.vh_xml_file, allow='local')
XMLResource(self.vh_xml_file,
base_url=os.path.dirname(self.vh_xml_file),
allow='sandbox')
with self.assertRaises(XMLSchemaResourceError) as ctx:
XMLResource(self.vh_xml_file, allow='remote')
self.assertTrue(
str(ctx.exception).startswith("block access to local resource"))
with self.assertRaises(XMLSchemaResourceError) as ctx:
XMLResource("https://xmlschema.test/vehicles.xsd", allow='local')
self.assertEqual(
str(ctx.exception),
"block access to remote resource https://xmlschema.test/vehicles.xsd"
)
with self.assertRaises(XMLSchemaResourceError) as ctx:
XMLResource("https://xmlschema.test/vehicles.xsd", allow='sandbox')
self.assertEqual(
str(ctx.exception),
"block access to files out of sandbox requires 'base_url' to be set"
)
with self.assertRaises(XMLSchemaResourceError) as ctx:
XMLResource("/tmp/vehicles.xsd", allow='sandbox')
self.assertEqual(
str(ctx.exception),
"block access to files out of sandbox requires 'base_url' to be set",
)
source = "/tmp/vehicles.xsd"
with self.assertRaises(XMLSchemaResourceError) as ctx:
XMLResource(source, base_url=base_url, allow='sandbox')
self.assertEqual(
str(ctx.exception),
"block access to out of sandbox file {}".format(
normalize_url(source)),
)
with self.assertRaises(TypeError) as ctx:
XMLResource("https://xmlschema.test/vehicles.xsd", allow=None)
self.assertEqual(
str(ctx.exception),
"invalid type <class 'NoneType'> for the attribute 'allow'")
with self.assertRaises(ValueError) as ctx:
XMLResource("https://xmlschema.test/vehicles.xsd", allow='any')
self.assertEqual(str(ctx.exception),
"'allow' attribute: 'any' is not a security mode")
def test_xml_resource_close(self):
resource = XMLResource(self.vh_xml_file)
resource.close()
xml_file = resource.open()
self.assertTrue(callable(xml_file.read))
with open(self.vh_xml_file) as xml_file:
resource = XMLResource(source=xml_file)
resource.close()
with self.assertRaises(ValueError):
resource.open()
def test_xml_resource_open(self):
resource = XMLResource(self.vh_xml_file)
xml_file = resource.open()
self.assertIsNot(xml_file, resource.source)
data = xml_file.read().decode('utf-8')
self.assertTrue(data.startswith('<?xml '))
xml_file.close()
resource = XMLResource('<A/>')
self.assertRaises(XMLSchemaResourceError, resource.open)
resource = XMLResource(source=open(self.vh_xml_file))
xml_file = resource.open()
self.assertIs(xml_file, resource.source)
xml_file.close()
def test_xml_resource_get_locations(self):
resource = XMLResource(self.col_xml_file)
self.check_url(resource.url, normalize_url(self.col_xml_file))
locations = resource.get_locations([('ns', 'other.xsd')])
self.assertEqual(len(locations), 2)
self.check_url(locations[0][1], os.path.join(self.col_dir,
'other.xsd'))
def test_xml_resource_defuse(self):
resource = XMLResource(self.vh_xml_file, defuse='never')
self.assertEqual(resource.defuse, 'never')
self.assertEqual(resource.parse, etree_parse)
self.assertEqual(resource.iterparse, etree_iterparse)
self.assertEqual(resource.fromstring, etree_fromstring)
resource.defuse = 'always'
self.assertEqual(resource.parse, defused_etree.parse)
self.assertEqual(resource.iterparse, defused_etree.iterparse)
self.assertEqual(resource.fromstring, defused_etree.fromstring)
resource.defuse = 'remote'
self.assertEqual(resource.parse, etree_parse)
self.assertEqual(resource.iterparse, etree_iterparse)
self.assertEqual(resource.fromstring, etree_fromstring)
resource._url = 'http://localhost'
self.assertEqual(resource.parse, defused_etree.parse)
self.assertEqual(resource.iterparse, defused_etree.iterparse)
self.assertEqual(resource.fromstring, defused_etree.fromstring)
self.assertRaises(ValueError,
XMLResource,
self.vh_xml_file,
defuse='all')
self.assertRaises(ValueError,
XMLResource,
self.vh_xml_file,
defuse=None)
def test_fid_with_name_attr(self):
"""XMLResource gets correct data when passed a file like object
with a name attribute that isn't on disk.
These file descriptors appear when working with the contents from a
zip using the zipfile module and with Django files in some
instances.
"""
class FileProxy(object):
def __init__(self, fid, fake_name):
self._fid = fid
self.name = fake_name
def __getattr__(self, attr):
try:
return self.__dict__[attr]
except (KeyError, AttributeError):
return getattr(self.__dict__["_fid"], attr)
fake_name = "not__on____disk.xml"
with open(self.vh_xml_file) as schema_file:
resource = XMLResource(FileProxy(schema_file, fake_name))
self.assertIsNone(resource.url)
self.assertEqual(set(resource.get_namespaces().keys()),
{'vh', 'xsi'})
self.assertFalse(schema_file.closed)
def test_xml_resource_timeout(self):
resource = XMLResource(self.vh_xml_file, timeout=30)
self.assertEqual(resource.timeout, 30)
self.assertRaises(ValueError,
XMLResource,
self.vh_xml_file,
timeout='100')
self.assertRaises(ValueError, XMLResource, self.vh_xml_file, timeout=0)
def test_xml_resource_fromstring(self):
resource = XMLResource(self.vh_xml_file)
self.assertEqual(resource.defuse, 'remote')
self.assertEqual(resource.fromstring('<root/>').tag, 'root')
resource.defuse = 'always'
self.assertEqual(resource.fromstring('<root/>').tag, 'root')
def test_xml_resource_iterfind(self):
namespaces = {'xs': XSD_NAMESPACE}
resource = XMLResource(self.schema_class.meta_schema.source.url,
lazy=False)
self.assertFalse(resource.is_lazy())
lazy_resource = XMLResource(self.schema_class.meta_schema.source.url)
self.assertTrue(lazy_resource.is_lazy())
# Note: Element change with lazy resource so compare only tags
tags = [x.tag for x in resource.iterfind()]
self.assertEqual(len(tags), 1)
self.assertEqual(tags[0], '{%s}schema' % XSD_NAMESPACE)
self.assertListEqual(tags, [x.tag for x in lazy_resource.iterfind()])
tags = [x.tag for x in resource.iterfind(path='.')]
self.assertEqual(len(tags), 1)
self.assertEqual(tags[0], '{%s}schema' % XSD_NAMESPACE)
self.assertListEqual(tags,
[x.tag for x in lazy_resource.iterfind(path='.')])
tags = [x.tag for x in resource.iterfind(path='*')]
self.assertEqual(len(tags), 156)
self.assertEqual(tags[0], '{%s}annotation' % XSD_NAMESPACE)
self.assertListEqual(tags,
[x.tag for x in lazy_resource.iterfind(path='*')])
tags = [x.tag for x in resource.iterfind('xs:complexType', namespaces)]
self.assertEqual(len(tags), 35)
self.assertTrue(
all(t == '{%s}complexType' % XSD_NAMESPACE for t in tags))
self.assertListEqual(tags, [
x.tag for x in lazy_resource.iterfind('xs:complexType', namespaces)
])
tags = [
x.tag
for x in resource.iterfind('. /. / xs:complexType', namespaces)
]
self.assertEqual(len(tags), 35)
self.assertTrue(
all(t == '{%s}complexType' % XSD_NAMESPACE for t in tags))
self.assertListEqual(tags, [
x.tag for x in lazy_resource.iterfind('. /. / xs:complexType',
namespaces)
])
def test_xml_resource_get_locations(self):
resource = XMLResource(self.col_xml_file)
self.assertEqual(resource.url, normalize_url(self.col_xml_file))
locations = resource.get_locations([('ns', 'other.xsd')])
self.assertEqual(len(locations), 2)
if not IS_WIN_PLATFORM:
self.assertEqual(
locations[0][1].lower(),
FILE_SCHEME.format(self.col_dir).lower() + '/other.xsd')
def test_xml_resource_from_string(self):
with open(self.vh_xsd_file) as schema_file:
schema_text = schema_file.read()
resource = XMLResource(schema_text)
self.assertEqual(resource.source, schema_text)
self.assertEqual(resource.root.tag,
'{http://www.w3.org/2001/XMLSchema}schema')
self.assertIsNone(resource.url)
self.assertIsNone(resource.document)
self.assertTrue(resource.text.startswith('<xs:schema'))
invalid_xml = '<tns0:root>missing namespace declaration</tns0:root>'
with self.assertRaises(ElementTree.ParseError) as ctx:
XMLResource(invalid_xml)
self.assertEqual(str(ctx.exception),
'unbound prefix: line 1, column 0')
def test_init_from_xml_resource(self):
xml_file = os.path.join(self.test_dir,
'resources/pw/CO_bgfs_relax.xml')
document = PwDocument(source=XMLResource(xml_file))
if platform.system() == 'Linux':
self.assertEqual(document.filename, xml_file)
else:
self.assertTrue(document.filename.endswith('CO_bgfs_relax.xml'))
self.assertTrue(
document.schema.url.endswith("qeschema/schemas/qes.xsd"))
def test_xml_resource_parse(self):
resource = XMLResource(self.vh_xml_file)
self.assertEqual(resource.defuse, 'remote')
xml_document = resource.parse(self.col_xml_file)
self.assertTrue(is_etree_element(xml_document.getroot()))
resource.defuse = 'always'
xml_document = resource.parse(self.col_xml_file)
self.assertTrue(is_etree_element(xml_document.getroot()))
def test_xml_resource_iterparse(self):
resource = XMLResource(self.vh_xml_file)
self.assertEqual(resource.defuse, 'remote')
for _, elem in resource.iterparse(self.col_xml_file, events=('end', )):
self.assertTrue(is_etree_element(elem))
resource.defuse = 'always'
for _, elem in resource.iterparse(self.col_xml_file, events=('end', )):
self.assertTrue(is_etree_element(elem))
def test_xml_resource_get_namespaces(self):
with open(self.vh_xml_file) as schema_file:
resource = XMLResource(schema_file)
self.assertEqual(resource.url, normalize_url(self.vh_xml_file))
self.assertEqual(set(resource.get_namespaces().keys()),
{'vh', 'xsi'})
with open(self.vh_xsd_file) as schema_file:
resource = XMLResource(schema_file)
self.assertEqual(resource.url, normalize_url(self.vh_xsd_file))
self.assertEqual(set(resource.get_namespaces().keys()),
{'xs', 'vh'})
resource = XMLResource(self.col_xml_file)
self.assertEqual(resource.url, normalize_url(self.col_xml_file))
self.assertEqual(set(resource.get_namespaces().keys()), {'col', 'xsi'})
resource = XMLResource(self.col_xsd_file)
self.assertEqual(resource.url, normalize_url(self.col_xsd_file))
self.assertEqual(set(resource.get_namespaces().keys()), {'', 'xs'})
def test_xml_resource_from_string(self):
with open(self.vh_xsd_file) as schema_file:
schema_text = schema_file.read()
resource = XMLResource(schema_text)
self.assertEqual(resource.source, schema_text)
self.assertEqual(resource.root.tag,
'{http://www.w3.org/2001/XMLSchema}schema')
self.assertIsNone(resource.url)
self.assertIsNone(resource.document)
self.assertTrue(resource.text.startswith('<xs:schema'))
def test_xml_resource_from_url(self):
resource = XMLResource(self.vh_xml_file)
self.assertEqual(resource.source, self.vh_xml_file)
self.assertEqual(resource.root.tag,
'{http://example.com/vehicles}vehicles')
self.check_url(resource.url, self.vh_xml_file)
self.assertIsNone(resource.document)
self.assertIsNone(resource.text)
resource.load()
self.assertTrue(resource.text.startswith('<?xml'))
resource = XMLResource(self.vh_xml_file, lazy=False)
self.assertEqual(resource.source, self.vh_xml_file)
self.assertEqual(resource.root.tag,
'{http://example.com/vehicles}vehicles')
self.check_url(resource.url, self.vh_xml_file)
self.assertIsInstance(resource.document, ElementTree.ElementTree)
self.assertIsNone(resource.text)
resource.load()
self.assertTrue(resource.text.startswith('<?xml'))
def test_xml_resource_from_string_io(self):
with open(self.vh_xsd_file) as schema_file:
schema_text = schema_file.read()
schema_file = StringIO(schema_text)
resource = XMLResource(schema_file)
self.assertEqual(resource.source, schema_file)
self.assertEqual(resource.root.tag,
'{http://www.w3.org/2001/XMLSchema}schema')
self.assertIsNone(resource.url)
self.assertIsNone(resource.document)
self.assertTrue(resource.text.startswith('<xs:schema'))
schema_file = StringIO(schema_text)
resource = XMLResource(schema_file, lazy=False)
self.assertEqual(resource.source, schema_file)
self.assertEqual(resource.root.tag,
'{http://www.w3.org/2001/XMLSchema}schema')
self.assertIsNone(resource.url)
self.assertIsInstance(resource.document, ElementTree.ElementTree)
self.assertTrue(resource.text.startswith('<xs:schema'))
def test_xml_resource_from_lxml(self):
vh_etree = lxml_etree_parse(self.vh_xml_file)
vh_root = vh_etree.getroot()
resource = XMLResource(vh_etree)
self.assertEqual(resource.source, vh_etree)
self.assertEqual(resource.document, vh_etree)
self.assertEqual(resource.root.tag,
'{http://example.com/vehicles}vehicles')
self.assertIsNone(resource.url)
self.assertIsNone(resource.text)
resource.load()
self.assertIsNone(resource.text)
resource = XMLResource(vh_root)
self.assertEqual(resource.source, vh_root)
self.assertEqual(resource.root.tag,
'{http://example.com/vehicles}vehicles')
self.assertIsNone(resource.url)
self.assertIsNone(resource.text)
resource.load()
self.assertIsNone(resource.text)
def test_xml_resource_from_file(self):
with open(self.vh_schema_file) as schema_file:
resource = XMLResource(schema_file)
self.assertEqual(resource.source, schema_file)
self.assertEqual(resource.root.tag,
'{http://www.w3.org/2001/XMLSchema}schema')
self.check_url(resource.url, self.vh_schema_file)
self.assertIsNone(resource.document)
self.assertIsNone(resource.text)
resource.load()
self.assertTrue(resource.text.startswith('<xs:schema'))
with open(self.vh_schema_file) as schema_file:
resource = XMLResource(schema_file, lazy=False)
self.assertEqual(resource.source, schema_file)
self.assertEqual(resource.root.tag,
'{http://www.w3.org/2001/XMLSchema}schema')
self.check_url(resource.url, self.vh_schema_file)
self.assertIsInstance(resource.document, ElementTree.ElementTree)
self.assertIsNone(resource.text)
resource.load()
self.assertTrue(resource.text.startswith('<xs:schema'))
def test_xml_resource_get_namespaces(self):
with open(self.vh_xml_file) as schema_file:
resource = XMLResource(schema_file)
self.assertIsNone(resource.url)
self.assertEqual(set(resource.get_namespaces().keys()),
{'vh', 'xsi'})
self.assertFalse(schema_file.closed)
with open(self.vh_xsd_file) as schema_file:
resource = XMLResource(schema_file)
self.assertIsNone(resource.url)
self.assertEqual(set(resource.get_namespaces().keys()),
{'xs', 'vh'})
self.assertFalse(schema_file.closed)
resource = XMLResource(self.col_xml_file)
self.assertEqual(resource.url, normalize_url(self.col_xml_file))
self.assertEqual(set(resource.get_namespaces().keys()), {'col', 'xsi'})
resource = XMLResource(self.col_xsd_file)
self.assertEqual(resource.url, normalize_url(self.col_xsd_file))
self.assertEqual(set(resource.get_namespaces().keys()), {'', 'xs'})
resource = XMLResource("""<?xml version="1.0" ?>
<root xmlns="tns1">
<tns:elem1 xmlns:tns="tns1" xmlns="unknown"/>
</root>""",
lazy=False)
self.assertEqual(set(resource.get_namespaces().keys()),
{'', 'tns', 'default'})
resource._lazy = True
self.assertEqual(resource.get_namespaces().keys(), {''})
resource = XMLResource("""<?xml version="1.0" ?>
<root xmlns:tns="tns1">
<tns:elem1 xmlns:tns="tns1" xmlns="unknown"/>
</root>""",
lazy=False)
self.assertEqual(set(resource.get_namespaces().keys()),
{'default', 'tns'})
self.assertEqual(
resource.get_namespaces(root_only=True).keys(), {'tns'})
resource._lazy = True
self.assertEqual(resource.get_namespaces().keys(), {'tns'})
resource = XMLResource("""<?xml version="1.0" ?>
<root xmlns:tns="tns1">
<tns:elem1 xmlns:tns="tns3" xmlns="unknown"/>
</root>""",
lazy=False)
self.assertEqual(set(resource.get_namespaces().keys()),
{'default', 'tns', 'tns0'})
resource._lazy = True
self.assertEqual(resource.get_namespaces().keys(), {'tns'})
def test_xml_resource_from_url(self):
resource = XMLResource(self.vh_xml_file)
self.assertEqual(resource.source, self.vh_xml_file)
self.assertEqual(resource.root.tag,
'{http://example.com/vehicles}vehicles')
self.assertEqual(resource.url.lower(),
FILE_SCHEME.format(self.vh_xml_file).lower())
self.assertIsNone(resource.document)
self.assertIsNone(resource.text)
resource.load()
self.assertTrue(resource.text.startswith('<?xml'))
resource = XMLResource(self.vh_xml_file, lazy=False)
self.assertEqual(resource.source, self.vh_xml_file)
self.assertEqual(resource.root.tag,
'{http://example.com/vehicles}vehicles')
if not IS_WIN_PLATFORM:
self.assertEqual(resource.url,
FILE_SCHEME.format(self.vh_xml_file))
self.assertIsInstance(resource.document, ElementTree.ElementTree)
self.assertIsNone(resource.text)
resource.load()
self.assertTrue(resource.text.startswith('<?xml'))
def test_get_context(self):
source, schema = get_context(self.col_xml_file)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema)
source, schema = get_context(self.col_xml_file, self.col_xsd_file)
self.assertIsInstance(source, XMLResource)
self.assertIsInstance(schema, XMLSchema)
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, XMLSchema)
# 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, XMLSchema)
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, XMLSchema)
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, XMLSchema)
def test_xml_resource_copy(self):
resource = XMLResource(self.vh_xml_file)
resource2 = resource.copy(defuse='never')
self.assertEqual(resource2.defuse, 'never')
resource2 = resource.copy(timeout=30)
self.assertEqual(resource2.timeout, 30)
resource2 = resource.copy(lazy=False)
self.assertFalse(resource2.is_lazy())
self.assertIsNone(resource2.text)
self.assertIsNone(resource.text)
resource.load()
self.assertIsNotNone(resource.text)
resource2 = resource.copy()
self.assertEqual(resource.text, resource2.text)
