lxml.tests.test_incremental

1 # -*- coding: utf-8 -*- 2 3 """ 4 Tests for the incremental XML serialisation API. 5 6 Tests require Python 2.5 or later. 7 """ 8 9 from __future__ import with_statement 10 11 import unittest 12 import tempfile, os, sys 13 14 this_dir = os.path.dirname(__file__) 15 if this_dir not in sys.path: 16 sys.path.insert(0, this_dir) # needed for Py3 17 18 from common_imports import etree, BytesIO, HelperTestCase, skipIf

19 20 -class _XmlFileTestCaseBase(HelperTestCase):

21 _file = None # to be set by specific subtypes below 22

23 - def test_element(self):

24 with etree.xmlfile(self._file) as xf: 25 with xf.element('test'): 26 pass 27 self.assertXml('<test></test>')

28

29 - def test_element_write_text(self):

30 with etree.xmlfile(self._file) as xf: 31 with xf.element('test'): 32 xf.write('toast') 33 self.assertXml('<test>toast</test>')

34

35 - def test_element_nested(self):

36 with etree.xmlfile(self._file) as xf: 37 with xf.element('test'): 38 with xf.element('toast'): 39 with xf.element('taste'): 40 xf.write('conTent') 41 self.assertXml('<test><toast><taste>conTent</taste></toast></test>')

42

43 - def test_element_nested_with_text(self):

44 with etree.xmlfile(self._file) as xf: 45 with xf.element('test'): 46 xf.write('con') 47 with xf.element('toast'): 48 xf.write('tent') 49 with xf.element('taste'): 50 xf.write('inside') 51 xf.write('tnet') 52 xf.write('noc') 53 self.assertXml('<test>con<toast>tent<taste>inside</taste>' 54 'tnet</toast>noc</test>')

55

56 - def test_write_Element(self):

57 with etree.xmlfile(self._file) as xf: 58 xf.write(etree.Element('test')) 59 self.assertXml('<test/>')

60

61 - def test_write_Element_repeatedly(self):

62 element = etree.Element('test') 63 with etree.xmlfile(self._file) as xf: 64 with xf.element('test'): 65 for i in range(100): 66 xf.write(element) 67 68 tree = self._parse_file() 69 self.assertTrue(tree is not None) 70 self.assertEqual(100, len(tree.getroot())) 71 self.assertEqual(set(['test']), set(el.tag for el in tree.getroot()))

72

73 - def test_namespace_nsmap(self):

74 with etree.xmlfile(self._file) as xf: 75 with xf.element('{nsURI}test', nsmap={'x': 'nsURI'}): 76 pass 77 self.assertXml('<x:test xmlns:x="nsURI"></x:test>')

78

79 - def test_namespace_nested_nsmap(self):

80 with etree.xmlfile(self._file) as xf: 81 with xf.element('test', nsmap={'x': 'nsURI'}): 82 with xf.element('{nsURI}toast'): 83 pass 84 self.assertXml('<test xmlns:x="nsURI"><x:toast></x:toast></test>')

85

86 - def test_anonymous_namespace(self):

87 with etree.xmlfile(self._file) as xf: 88 with xf.element('{nsURI}test'): 89 pass 90 self.assertXml('<ns0:test xmlns:ns0="nsURI"></ns0:test>')

91

92 - def test_namespace_nested_anonymous(self):

93 with etree.xmlfile(self._file) as xf: 94 with xf.element('test'): 95 with xf.element('{nsURI}toast'): 96 pass 97 self.assertXml('<test><ns0:toast xmlns:ns0="nsURI"></ns0:toast></test>')

98

99 - def test_default_namespace(self):

100 with etree.xmlfile(self._file) as xf: 101 with xf.element('{nsURI}test', nsmap={None: 'nsURI'}): 102 pass 103 self.assertXml('<test xmlns="nsURI"></test>')

104

105 - def test_nested_default_namespace(self):

106 with etree.xmlfile(self._file) as xf: 107 with xf.element('{nsURI}test', nsmap={None: 'nsURI'}): 108 with xf.element('{nsURI}toast'): 109 pass 110 self.assertXml('<test xmlns="nsURI"><toast></toast></test>')

111

112 - def test_nested_default_namespace_and_other(self):

113 with etree.xmlfile(self._file) as xf: 114 with xf.element('{nsURI}test', nsmap={None: 'nsURI', 'p': 'ns2'}): 115 with xf.element('{nsURI}toast'): 116 pass 117 with xf.element('{ns2}toast'): 118 pass 119 self.assertXml( 120 '<test xmlns="nsURI" xmlns:p="ns2"><toast></toast><p:toast></p:toast></test>')

121

122 - def test_pi(self):

123 with etree.xmlfile(self._file) as xf: 124 xf.write(etree.ProcessingInstruction('pypi')) 125 with xf.element('test'): 126 pass 127 self.assertXml('<?pypi ?><test></test>')

128

129 - def test_comment(self):

130 with etree.xmlfile(self._file) as xf: 131 xf.write(etree.Comment('a comment')) 132 with xf.element('test'): 133 pass 134 self.assertXml('<test></test>')

135

136 - def test_attribute(self):

137 with etree.xmlfile(self._file) as xf: 138 with xf.element('test', attrib={'k': 'v'}): 139 pass 140 self.assertXml('<test k="v"></test>')

141

142 - def test_escaping(self):

143 with etree.xmlfile(self._file) as xf: 144 with xf.element('test'): 145 xf.write('Comments: \n') 146 xf.write('Entities: &') 147 self.assertXml( 148 '<test>Comments: \nEntities: &amp;</test>')

149

150 - def test_encoding(self):

151 with etree.xmlfile(self._file, encoding='utf16') as xf: 152 with xf.element('test'): 153 xf.write('toast') 154 self.assertXml('<test>toast</test>', encoding='utf16')

155

156 - def test_buffering(self):

157 with etree.xmlfile(self._file, buffered=False) as xf: 158 with xf.element('test'): 159 self.assertXml("<test>") 160 xf.write('toast') 161 self.assertXml("<test>toast") 162 with xf.element('taste'): 163 self.assertXml("<test>toast<taste>") 164 xf.write('some', etree.Element("more"), "toast") 165 self.assertXml("<test>toast<taste>some<more/>toast") 166 self.assertXml("<test>toast<taste>some<more/>toast</taste>") 167 xf.write('end') 168 self.assertXml("<test>toast<taste>some<more/>toast</taste>end") 169 self.assertXml("<test>toast<taste>some<more/>toast</taste>end</test>") 170 self.assertXml("<test>toast<taste>some<more/>toast</taste>end</test>")

171

172 - def test_flush(self):

173 with etree.xmlfile(self._file, buffered=True) as xf: 174 with xf.element('test'): 175 self.assertXml("") 176 xf.write('toast') 177 self.assertXml("") 178 with xf.element('taste'): 179 self.assertXml("") 180 xf.flush() 181 self.assertXml("<test>toast<taste>") 182 self.assertXml("<test>toast<taste>") 183 self.assertXml("<test>toast<taste>") 184 self.assertXml("<test>toast<taste></taste></test>")

185

186 - def test_failure_preceding_text(self):

187 try: 188 with etree.xmlfile(self._file) as xf: 189 xf.write('toast') 190 except etree.LxmlSyntaxError: 191 self.assertTrue(True) 192 else: 193 self.assertTrue(False)

194

195 - def test_failure_trailing_text(self):

196 with etree.xmlfile(self._file) as xf: 197 with xf.element('test'): 198 pass 199 try: 200 xf.write('toast') 201 except etree.LxmlSyntaxError: 202 self.assertTrue(True) 203 else: 204 self.assertTrue(False)

205

206 - def test_failure_trailing_Element(self):

207 with etree.xmlfile(self._file) as xf: 208 with xf.element('test'): 209 pass 210 try: 211 xf.write(etree.Element('test')) 212 except etree.LxmlSyntaxError: 213 self.assertTrue(True) 214 else: 215 self.assertTrue(False)

216

217 - def test_closing_out_of_order_in_error_case(self):

218 cm_exit = None 219 try: 220 with etree.xmlfile(self._file) as xf: 221 x = xf.element('test') 222 cm_exit = x.__exit__ 223 x.__enter__() 224 raise ValueError('123') 225 except ValueError: 226 self.assertTrue(cm_exit) 227 try: 228 cm_exit(ValueError, ValueError("huhu"), None) 229 except etree.LxmlSyntaxError: 230 self.assertTrue(True) 231 else: 232 self.assertTrue(False) 233 else: 234 self.assertTrue(False)

235

236 - def _read_file(self):

237 pos = self._file.tell() 238 self._file.seek(0) 239 try: 240 return self._file.read() 241 finally: 242 self._file.seek(pos)

243

244 - def _parse_file(self):

245 pos = self._file.tell() 246 self._file.seek(0) 247 try: 248 return etree.parse(self._file) 249 finally: 250 self._file.seek(pos)

251

252 - def tearDown(self):

253 if self._file is not None: 254 self._file.close()

255

256 - def assertXml(self, expected, encoding='utf8'):

257 self.assertEqual(self._read_file().decode(encoding), expected)

258

259 260 -class BytesIOXmlFileTestCase(_XmlFileTestCaseBase):

261 - def setUp(self):

262 self._file = BytesIO()

263

264 - def test_filelike_close(self):

265 with etree.xmlfile(self._file, close=True) as xf: 266 with xf.element('test'): 267 pass 268 self.assertRaises(ValueError, self._file.getvalue)

269

270 271 -class TempXmlFileTestCase(_XmlFileTestCaseBase):

272 - def setUp(self):

273 self._file = tempfile.TemporaryFile()

274

275 276 -class TempPathXmlFileTestCase(_XmlFileTestCaseBase):

277 - def setUp(self):

278 self._tmpfile = tempfile.NamedTemporaryFile() 279 self._file = self._tmpfile.name

280

281 - def tearDown(self):

282 try: 283 self._tmpfile.close() 284 finally: 285 if os.path.exists(self._tmpfile.name): 286 os.unlink(self._tmpfile.name)

287

288 - def _read_file(self):

289 self._tmpfile.seek(0) 290 return self._tmpfile.read()

291

292 - def _parse_file(self):

293 self._tmpfile.seek(0) 294 return etree.parse(self._tmpfile)

295 296 @skipIf(True, "temp file behaviour is too platform specific here")

297 - def test_buffering(self):

298 pass

299 300 @skipIf(True, "temp file behaviour is too platform specific here")

301 - def test_flush(self):

302 pass

303

304 305 -class SimpleFileLikeXmlFileTestCase(_XmlFileTestCaseBase):

306 - class SimpleFileLike(object):

307 - def __init__(self, target):

308 self._target = target 309 self.write = target.write 310 self.tell = target.tell 311 self.seek = target.seek 312 self.closed = False

313

314 - def close(self):

315 assert not self.closed 316 self.closed = True 317 self._target.close()

318

319 - def setUp(self):

320 self._target = BytesIO() 321 self._file = self.SimpleFileLike(self._target)

322

323 - def _read_file(self):

324 return self._target.getvalue()

325

326 - def _parse_file(self):

327 pos = self._file.tell() 328 self._target.seek(0) 329 try: 330 return etree.parse(self._target) 331 finally: 332 self._target.seek(pos)

333

334 - def test_filelike_not_closing(self):

335 with etree.xmlfile(self._file) as xf: 336 with xf.element('test'): 337 pass 338 self.assertFalse(self._file.closed)

339

340 - def test_filelike_close(self):

341 with etree.xmlfile(self._file, close=True) as xf: 342 with xf.element('test'): 343 pass 344 self.assertTrue(self._file.closed) 345 self._file = None # prevent closing in tearDown()

346

347 348 -class HtmlFileTestCase(_XmlFileTestCaseBase):

349 - def setUp(self):

350 self._file = BytesIO()

351

352 - def test_void_elements(self):

353 # http://www.w3.org/TR/html5/syntax.html#elements-0 354 void_elements = set([ 355 "area", "base", "br", "col", "embed", "hr", "img", 356 "input", "keygen", "link", "meta", "param", 357 "source", "track", "wbr" 358 ]) 359 360 # FIXME: These don't get serialized as void elements. 361 void_elements.difference_update([ 362 'area', 'embed', 'keygen', 'source', 'track', 'wbr' 363 ]) 364 365 for tag in sorted(void_elements): 366 with etree.htmlfile(self._file) as xf: 367 xf.write(etree.Element(tag)) 368 self.assertXml('<%s>' % tag) 369 self._file = BytesIO()

370

371 - def test_write_declaration(self):

372 with etree.htmlfile(self._file) as xf: 373 try: 374 xf.write_declaration() 375 except etree.LxmlSyntaxError: 376 self.assertTrue(True) 377 else: 378 self.assertTrue(False) 379 xf.write(etree.Element('html'))

380

381 - def test_write_namespaced_element(self):

382 with etree.htmlfile(self._file) as xf: 383 xf.write(etree.Element('{some_ns}some_tag')) 384 self.assertXml('<ns0:some_tag xmlns:ns0="some_ns"></ns0:some_tag>')

385

386 - def test_open_namespaced_element(self):

387 with etree.htmlfile(self._file) as xf: 388 with xf.element("{some_ns}some_tag"): 389 pass 390 self.assertXml('<ns0:some_tag xmlns:ns0="some_ns"></ns0:some_tag>')

391

392 393 -def test_suite():

394 suite = unittest.TestSuite() 395 suite.addTests([unittest.makeSuite(BytesIOXmlFileTestCase), 396 unittest.makeSuite(TempXmlFileTestCase), 397 unittest.makeSuite(TempPathXmlFileTestCase), 398 unittest.makeSuite(SimpleFileLikeXmlFileTestCase), 399 unittest.makeSuite(HtmlFileTestCase), 400 ]) 401 return suite

402 403 if __name__ == '__main__': 404 print('to test use test.py %s' % __file__) 405

Source Code for Module lxml.tests.test_incremental_xmlfile