def test_one_uri(count, uri, exception, tester=tester, module=domMod):
tester.startTest("Document %d non-validating" % count)
src = InputSource.DefaultFactory.fromUri(uri, BASE_PATH)
if exception:
tester.testException(module.NonvalParse, (src, ), ReaderException)
else:
doc = module.NonvalParse(src)
stream = cStringIO.StringIO()
Domlette.Print(doc, stream)
src = InputSource.DefaultFactory.fromUri(uri, BASE_PATH)
tester.compare(src.read(), stream.getvalue(), func=CompareXml)
tester.testDone()
tester.startTest("Document %d validating" % count)
src = InputSource.DefaultFactory.fromUri(uri, BASE_PATH)
if exception:
tester.testException(module.NonvalParse, (src, ), ReaderException)
else:
doc = module.ValParse(src)
stream = cStringIO.StringIO()
Domlette.Print(doc, stream)
src = InputSource.DefaultFactory.fromUri(uri, BASE_PATH)
tester.compare(src.read(), stream.getvalue(), func=CompareXml)
tester.testDone()
return
def doTest(tester, title, src, expected):
tester.startTest(title)
doc = READER.parseString(src, BASE_URI)
st = cStringIO.StringIO()
Domlette.Print(doc, stream=st)
compared = st.getvalue()
tester.compare(expected,
compared,
func=TreeCompare.XmlTreeCompare,
diff=True)
tester.testDone()
return
def Test(tester):
tester.startGroup('XML and TR9401 Catalogs')
tester.startTest('Parse an XML Catalog supplied via a URI')
cat_path = os.path.join('Xml', 'Core', 'xcatalog.xml')
cat_uri = Uri.OsPathToUri(cat_path, attemptAbsolute=1)
cat = Catalog(cat_uri)
tester.testDone()
tf_path = os.path.join('Xml', 'Core', 'include1.xml')
try:
fd = open(tf_path)
orig = fd.read()
fd.close()
except:
fd.close()
tester.warning('Could not read test file; skipping resolution tests.')
return
tester.startTest('Parse an XML Catalog supplied via an InputSource')
fd = open(cat_path, 'rb')
cat_data = fd.read()
fd.close()
isrc = NoCatalogFactory.fromString(cat_data, cat_uri)
cat = Catalog()
cat.isrc = isrc
cat.parse()
tester.testDone()
# The catalog object should map 'urn:bogus:include1.xml' to
# 'include1.xml' relative to the catalog's base URI.
tester.startTest('Resolve a relative URI reference in the catalog (1)')
expected = Uri.Absolutize('include1.xml', cat_uri)
tester.compare(expected, cat.uris['urn:bogus:include1.xml'])
tester.testDone()
# The catalog object should map 'urn:bogus:include1-from-parent.xml'
# to 'Core/include1.xml' relative to the catalog's base URI.
tester.startTest('Resolve a relative URI reference in the catalog (2)')
expected = Uri.Absolutize('Core/include1.xml', cat_uri)
tester.compare(expected, cat.uris['urn:bogus:include1-from-parent.xml'])
tester.testDone()
# Same as above but we'll change the base URI of the catalog and
# see if the results are still correct
tester.startTest('Resolve a relative URI reference in the catalog (3)')
alt_cat_path = os.path.join('Xml', 'xcatalog.xml')
alt_cat_uri = Uri.OsPathToUri(alt_cat_path, attemptAbsolute=1)
alt_cat_isrc = NoCatalogFactory.fromString(cat_data, alt_cat_uri)
alt_cat = Catalog()
alt_cat.isrc = alt_cat_isrc
alt_cat.uri = alt_cat_uri
alt_cat.parse()
expected = Uri.Absolutize('Core/include1.xml', alt_cat_uri)
tester.compare(expected,
alt_cat.uris['urn:bogus:include1-from-parent.xml'])
tester.testDone()
# Make sure the default catalog exists and isn't empty
tester.startTest('4Suite default catalog exists')
from Ft.Xml.Catalog import FT_CATALOG
entries = FT_CATALOG.publicIds or FT_CATALOG.uris
tester.compare(True, len(entries) > 0)
tester.testDone()
# A test of catalog support in Ft.Xml.InputSource
# (actually try to resolve a document URI with a catalog)
tester.startTest(
'Resolve doc via InputSource w/Catalog containing rel. URI (1)')
factory = InputSourceFactory(catalog=cat)
isrc = factory.fromUri('urn:bogus:include1.xml')
data = isrc.read()
isrc.close()
tester.compare(orig, data)
tester.testDone()
# A test of catalog support in Ft.Xml.InputSource
# (same as previous, just with the different catalog base URI)
tester.startTest(
'Resolve doc via InputSource w/Catalog containing rel. URI (2)')
factory = InputSourceFactory(catalog=alt_cat)
isrc = factory.fromUri('urn:bogus:include1-from-parent.xml')
data = isrc.read()
isrc.close()
tester.compare(orig, data)
tester.testDone()
# A test of catalog support in Ft.Xml.InputSource
# and resolving all combinations of Public and System IDs
tester.startTest('Resolve ext. entities w/Catalog')
xml_uri = Uri.Absolutize('test_catalog_INTERNAL.xml', cat_uri)
factory = InputSourceFactory(catalog=cat)
isrc = factory.fromString(XML_1, xml_uri)
doc = Domlette.NonvalidatingReader.parse(isrc)
st = cStringIO.StringIO()
Domlette.Print(doc, stream=st)
tester.compare(XML_EXPECTED_1, st.getvalue(), func=TreeCompare)
tester.testDone()
tester.groupDone()
return
def test_reader(tester, srcReader):
processor = XUpdate.Processor()
# ------------------------------------------------------
tester.startGroup('XUpdate instructions')
for name, src, xuSrc, expected, vars_ in [
("XUpdate spec example 1", src_1, xu_1, expected_1, {}),
("Append", src_2, xu_2, expected_2, {}),
("Update", src_3, xu_3, expected_3, {}),
("Remove", src_4, xu_4, expected_4, {}),
("Attribute/Value-Of", src_5, xu_5, expected_5, {
(None, 'child-name'): "FOO"
}),
("XUpdate spec append example", src_6, xu_6, expected_6, {}),
("Append attribute 1", src_7, xu_7, expected_7, {}),
("XUpdate use case 4", usecase_src, usecase_4, usecase_expected_4, {}),
("Rename", xu_rename_src, xu_rename, rename_expected, {}),
]:
tester.startTest(name)
uri = OsPathToUri('xupdate-test-src-' + quote(name) + '.xml',
attemptAbsolute=True)
isrc = InputSource.DefaultFactory.fromString(src, uri)
src = srcReader(isrc)
uri = OsPathToUri('xupdate-test-xup-' + quote(name) + '.xml',
attemptAbsolute=True)
isrc = InputSource.DefaultFactory.fromString(xuSrc, uri)
xu = xureader.fromSrc(isrc)
processor.execute(src, xu, variables=vars_)
st = cStringIO.StringIO()
Domlette.Print(src, stream=st)
tester.compare(expected,
st.getvalue(),
func=TreeCompare.TreeCompare,
diff=True)
tester.testDone()
tester.groupDone()
tester.startGroup('XUpdate exceptions')
uri = OsPathToUri('xupdate-test-src-2.xml', attemptAbsolute=True)
isrc = InputSource.DefaultFactory.fromString(src_2, uri)
src = srcReader(isrc)
from Ft.Xml.XUpdate import XUpdateException
for name, xuSrc, expected in [
('missing version attr', EXCEPTION_XUP_1, XUpdateException.NO_VERSION),
('missing select attr', EXCEPTION_XUP_2, XUpdateException.NO_SELECT),
('invalid select attr', EXCEPTION_XUP_3,
XUpdateException.INVALID_SELECT),
('syntax error', EXCEPTION_XUP_4, XUpdateException.SYNTAX_ERROR),
('missing test attr', EXCEPTION_XUP_5, XUpdateException.NO_TEST),
('unrecognized instruction', EXCEPTION_XUP_6,
XUpdateException.UNRECOGNIZED_INSTRUCTION),
]:
tester.startTest(name)
uri = OsPathToUri('xupdate-test-xup-' + quote(name) + '.xml',
attemptAbsolute=True)
isrc = InputSource.DefaultFactory.fromString(xuSrc, uri)
xu = xureader.fromSrc(isrc)
tester.testException(processor.execute, (src, xu), XUpdateException,
{'errorCode': expected})
tester.testDone()
tester.groupDone()
return
sys.stderr.flush()
return
try:
xml_reader = Domlette.NonvalidatingReader
xupdate_reader = XUpdate.Reader()
processor = XUpdate.Processor()
source_doc = xml_reader.parse(source_isrc)
CloseStream(source_isrc, quiet=True)
compiled_xupdate = xupdate_reader.fromSrc(xupdate_isrc)
CloseStream(xupdate_isrc, quiet=True)
processor.execute(source_doc, compiled_xupdate)
Domlette.Print(source_doc, stream=out_file)
except Exception, e:
import traceback
traceback.print_exc(1000, sys.stderr)
raise
try:
if out_file.isatty():
out_file.flush()
sys.stderr.write('\n')
else:
out_file.close()
except (IOError, ValueError):
pass
def test_extent_xinclude(tester, domMod):
tester.startGroup("Reader + External Entities + XInclude")
SRC_1 = """\
<?xml version='1.0'?>
<!DOCTYPE x [ <!ENTITY inc SYSTEM "include1.xml"> ]>
<x>
&inc;
</x>"""
expected_1 = """<?xml version='1.0' encoding='UTF-8'?><x>
<foo xml:base="%s"/>
</x>""" % Uri.Absolutize("include1.xml", BASE_PATH)
tester.startTest("External entity")
src = InputSource.DefaultFactory.fromString(SRC_1, BASE_PATH)
doc = domMod.NonvalParse(src)
stream = cStringIO.StringIO()
Domlette.Print(doc, stream)
tester.compare(expected_1, stream.getvalue(), func=TreeCompare.TreeCompare)
tester.testDone()
SRC_2 = """\
<?xml version='1.0'?>
<x xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="include1.xml"/>
</x>"""
expected_2 = """<?xml version='1.0' encoding='UTF-8'?>
<x xmlns:xi='http://www.w3.org/2001/XInclude'>
<foo xml:base="%s"/>
</x>""" % Uri.Absolutize("include1.xml", BASE_PATH)
tester.startTest("Basic XInclude")
src = InputSource.DefaultFactory.fromString(SRC_2, BASE_PATH)
doc = domMod.NonvalParse(src)
stream = cStringIO.StringIO()
Domlette.Print(doc, stream)
tester.compare(expected_2,
stream.getvalue(),
func=TreeCompare.NoWsTreeCompare)
tester.testDone()
SRC_3 = """\
<?xml version='1.0'?>
<x xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="include2.xml"/>
</x>"""
expected_3 = """<?xml version='1.0' encoding='UTF-8'?>
<x xmlns:xi='http://www.w3.org/2001/XInclude'>
<foo xml:base="%s">
<foo xml:base="%s"/>
</foo>
</x>
""" % (Uri.Absolutize("include2.xml",
BASE_PATH), Uri.Absolutize("include1.xml", BASE_PATH))
tester.startTest("Recursive XInclude")
src = InputSource.DefaultFactory.fromString(SRC_3, BASE_PATH)
doc = domMod.NonvalParse(src)
stream = cStringIO.StringIO()
Domlette.Print(doc, stream)
tester.compare(expected_3,
stream.getvalue(),
func=TreeCompare.NoWsTreeCompare)
tester.testDone()
SRC_4 = """\
<?xml version='1.0'?>
<x xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="include2.xml" parse='text'/>
</x>"""
from test_xinclude import LINESEP
expected_4 = """<?xml version='1.0' encoding='UTF-8'?>
<x xmlns:xi='http://www.w3.org/2001/XInclude'>
<?xml version='1.0' encoding='utf-8'?>%(linesep)s<foo xmlns:xi="http://www.w3.org/2001/XInclude">%(linesep)s <xi:include href="include1.xml"/>%(linesep)s</foo>
</x>
""" % {
'linesep': LINESEP
}
tester.startTest("XInclude text attribute")
src = InputSource.DefaultFactory.fromString(SRC_4, BASE_PATH)
doc = domMod.NonvalParse(src)
stream = cStringIO.StringIO()
Domlette.Print(doc, stream)
tester.compare(expected_4, stream.getvalue(), func=TreeCompare.TreeCompare)
tester.testDone()
tester.groupDone()
return
def test_nonvalidating_reader(tester, domMod):
tester.startGroup("non-Validating Reader")
tester.startTest("Simple XML")
src = InputSource.DefaultFactory.fromString(SMALL_XML, BASE_PATH)
doc = domMod.NonvalParse(src)
#Test a few of the nodes
tester.compare(2, len(doc.childNodes))
tester.compare(Node.PROCESSING_INSTRUCTION_NODE,
doc.childNodes[0].nodeType)
tester.compare("xml-stylesheet", doc.childNodes[0].target)
tester.compare('href="addr_book1.xsl" type="text/xml"',
doc.childNodes[0].data)
tester.compare(Node.ELEMENT_NODE, doc.childNodes[1].nodeType)
tester.compare('docelem', doc.childNodes[1].nodeName)
tester.compare(None, doc.childNodes[1].namespaceURI)
tester.compare(None, doc.childNodes[1].prefix)
tester.compare(doc.childNodes[1], doc.documentElement)
tester.compare(9, len(doc.documentElement.childNodes))
tester.compare(1, len(doc.documentElement.attributes.keys()))
tester.compare(('http://www.w3.org/2000/xmlns/', 'ft'),
doc.documentElement.attributes.keys()[0])
tester.compare('http://fourthought.com',
doc.documentElement.attributes.values()[0].value)
tester.compare(1, len(doc.documentElement.childNodes[1].attributes.keys()))
tester.compare((None, 'foo'),
doc.documentElement.childNodes[1].attributes.keys()[0])
tester.compare(
'bar', doc.documentElement.childNodes[1].attributes.values()[0].value)
tester.compare('Some Text',
doc.documentElement.childNodes[1].childNodes[0].data)
tester.compare('http://fourthought.com',
doc.documentElement.childNodes[5].namespaceURI)
tester.compare('ft', doc.documentElement.childNodes[5].prefix)
tester.compare(1, len(doc.documentElement.childNodes[5].attributes.keys()))
tester.compare(('http://fourthought.com', 'foo'),
doc.documentElement.childNodes[5].attributes.keys()[0])
tester.compare(
'nsbar',
doc.documentElement.childNodes[5].attributes.values()[0].value)
tester.testDone()
tester.startTest("Parse nasty XML")
src = InputSource.DefaultFactory.fromString(LARGE_XML, BASE_PATH)
doc = domMod.NonvalParse(src)
tester.testDone()
tester.startTest(
"Document with general entity defined in external subset (parse method 1)"
)
source_1 = GREETING
isrc = InputSource.DefaultFactory.fromString(source_1, BASE_PATH)
dom = domMod.NonvalParse(isrc, readExtDtd=1)
stream = cStringIO.StringIO()
Domlette.Print(dom, stream)
expected_1 = """\
<?xml version="1.0" encoding="UTF-8"?>
<greeting>hello world</greeting>
"""
tester.compare(expected_1, stream.getvalue(), func=CompareXml)
tester.testDone()
# same as previous test but going through Ft.Xml.Domlette
tester.startTest(
"Document with general entity defined in external subset (parse method 2)"
)
source_1 = GREETING
isrc = InputSource.DefaultFactory.fromString(source_1, BASE_PATH)
from Ft.Xml.Domlette import NonvalidatingReaderBase
reader = NonvalidatingReaderBase()
reader.kwargs['readExtDtd'] = 1
dom = reader.parse(isrc)
stream = cStringIO.StringIO()
Domlette.Print(dom, stream)
expected_1 = """\
<?xml version="1.0" encoding="UTF-8"?>
<greeting>hello world</greeting>
"""
tester.compare(expected_1, stream.getvalue(), func=CompareXml)
tester.testDone()
tester.groupDone()
def test_strip_elements(tester, domMod):
tester.startGroup("Strip Elements")
tester.startTest("Strip Elements")
src = "<ft:foo xmlns:ft='http://fourthought.com' xmlns:ft2='http://foo.com'><ft:bar> </ft:bar><ft:bar> F </ft:bar><ft:baz> Bar1 </ft:baz><ft2:bar> </ft2:bar><ft2:baz> Bar2 </ft2:baz><bar> </bar><baz> Bar3 </baz></ft:foo>"
stripElements = [(None, 'bar', 1), ('http://fourthought.com', 'bar', 1),
('http://foo.com', '*', 1)]
isrc = InputSource.DefaultFactory.fromString(src,
BASE_PATH,
stripElements=stripElements)
dom = domMod.NonvalParse(isrc)
tester.compare(None, dom.documentElement.childNodes[0].firstChild)
tester.compare(" F ", dom.documentElement.childNodes[1].firstChild.data)
tester.compare(" Bar1 ",
dom.documentElement.childNodes[2].firstChild.data)
tester.compare(None, dom.documentElement.childNodes[3].firstChild)
tester.compare(" Bar2 ", dom.documentElement.childNodes[4].firstChild.data)
tester.compare(None, dom.documentElement.childNodes[5].firstChild)
tester.compare(" Bar3 ",
dom.documentElement.childNodes[6].firstChild.data)
tester.testDone()
tester.startTest("Strip Elements with xml:space")
src = """\
<svg xml:space="preserve" width="1000" height="1000"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<desc>Salary Chart</desc>
<g style='stroke:#000000;stroke-width:1;font-family:Arial;font-size:16'>
<xsl:for-each select="ROWSET/ROW">
<xsl:call-template name="drawBar" xml:space="default">
<xsl:with-param name="rowIndex" select="position()"/>
<xsl:with-param name="ename" select="ENAME"/>
<xsl:with-param name="sal" select="number(SAL)"/>
</xsl:call-template>
</xsl:for-each>
</g>
</svg>"""
expected = """<?xml version="1.0" encoding="UTF-8"?>
<svg xml:space="preserve" width="1000" height="1000"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<desc>Salary Chart</desc>
<g style='stroke:#000000;stroke-width:1;font-family:Arial;font-size:16'>
<xsl:for-each select="ROWSET/ROW">
<xsl:call-template name="drawBar" xml:space="default"><xsl:with-param name="rowIndex" select="position()"/><xsl:with-param name="ename" select="ENAME"/><xsl:with-param name="sal" select="number(SAL)"/></xsl:call-template>
</xsl:for-each>
</g>
</svg>"""
src = """<?xml version="1.0" encoding="UTF-8"?>
<element xml:space="preserve">
<element>
<!-- surrounding WS should be preserved -->
</element>
</element>"""
stripElements = [(None, '*', True)]
isrc = InputSource.DefaultFactory.fromString(src,
BASE_PATH,
stripElements=stripElements)
dom = domMod.NonvalParse(isrc)
sio = cStringIO.StringIO()
Domlette.Print(dom, sio)
actual = sio.getvalue()
tester.compare(src, actual, func=TreeCompare.TreeCompare)
tester.testDone()
tester.groupDone()
return
