Source Code for Module lxml.tests.test_sax

  1  # -*- coding: utf-8 -*- 
  2   
  3  """ 
  4  Test cases related to SAX I/O 
  5  """ 
  6   
  7  import unittest, sys, os.path 
  8   
  9  this_dir = os.path.dirname(__file__) 
 10  if this_dir not in sys.path: 
 11      sys.path.insert(0, this_dir) # needed for Py3 
 12   
 13  from common_imports import HelperTestCase, make_doctest, BytesIO, _bytes 
 14  from lxml import sax 
 15  from xml.dom import pulldom 
 16   
 17   
 18 -class ETreeSaxTestCase(HelperTestCase): 
 19   
 20 -    def test_etree_sax_simple(self): 
 21          tree = self.parse('<a>ab<b/>ba</a>') 
 22          xml_out = self._saxify_serialize(tree) 
 23          self.assertEqual(_bytes('<a>ab<b/>ba</a>'), 
 24                            xml_out) 
 25   
 26 -    def test_etree_sax_double(self): 
 27          tree = self.parse('<a>ab<b>bb</b>ba</a>') 
 28          xml_out = self._saxify_serialize(tree) 
 29          self.assertEqual(_bytes('<a>ab<b>bb</b>ba</a>'), 
 30                            xml_out) 
 31   
 32 -    def test_etree_sax_comment(self): 
 33          tree = self.parse('<a>ab<!-- TEST -->ba</a>') 
 34          xml_out = self._saxify_serialize(tree) 
 35          self.assertEqual(_bytes('<a>abba</a>'), 
 36                            xml_out) 
 37   
 38 -    def test_etree_sax_pi(self): 
 39          tree = self.parse('<a>ab<?this and that?>ba</a>') 
 40          xml_out = self._saxify_serialize(tree) 
 41          self.assertEqual(_bytes('<a>ab<?this and that?>ba</a>'), 
 42                            xml_out) 
 43   
 44 -    def test_etree_sax_comment_root(self): 
 45          tree = self.parse('<!-- TEST --><a>ab</a>') 
 46          xml_out = self._saxify_serialize(tree) 
 47          self.assertEqual(_bytes('<a>ab</a>'), 
 48                            xml_out) 
 49   
 50 -    def test_etree_sax_pi_root(self): 
 51          tree = self.parse('<?this and that?><a>ab</a>') 
 52          xml_out = self._saxify_serialize(tree) 
 53          self.assertEqual(_bytes('<?this and that?><a>ab</a>'), 
 54                            xml_out) 
 55   
 56 -    def test_etree_sax_attributes(self): 
 57          tree = self.parse('<a aa="5">ab<b b="5"/>ba</a>') 
 58          xml_out = self._saxify_serialize(tree) 
 59          self.assertEqual(_bytes('<a aa="5">ab<b b="5"/>ba</a>'), 
 60                            xml_out) 
 61   
 62 -    def test_etree_sax_ns1(self): 
 63          tree = self.parse('<a xmlns="bla">ab<b>bb</b>ba</a>') 
 64          new_tree = self._saxify_unsaxify(tree) 
 65          root = new_tree.getroot() 
 66          self.assertEqual('{bla}a', 
 67                           root.tag) 
 68          self.assertEqual('{bla}b', 
 69                           root[0].tag) 
 70   
 71 -    def test_etree_sax_ns2(self): 
 72          tree = self.parse('<a xmlns="blaA">ab<b:b xmlns:b="blaB">bb</b:b>ba</a>') 
 73          new_tree = self._saxify_unsaxify(tree) 
 74          root = new_tree.getroot() 
 75          self.assertEqual('{blaA}a', 
 76                           root.tag) 
 77          self.assertEqual('{blaB}b', 
 78                           root[0].tag) 
 79   
 80 -    def test_sax_to_pulldom(self): 
 81          tree = self.parse('<a xmlns="blaA">ab<b:b xmlns:b="blaB">bb</b:b>ba</a>') 
 82          handler = pulldom.SAX2DOM() 
 83          sax.saxify(tree, handler) 
 84          dom = handler.document 
 85   
 86          self.assertEqual('a', 
 87                           dom.firstChild.localName) 
 88          self.assertEqual('blaA', 
 89                           dom.firstChild.namespaceURI) 
 90   
 91          children = dom.firstChild.childNodes 
 92          self.assertEqual('ab', 
 93                           children[0].nodeValue) 
 94          self.assertEqual('blaB', 
 95                           children[1].namespaceURI) 
 96          self.assertEqual('ba', 
 97                           children[2].nodeValue) 
 98   
 99 -    def test_element_sax(self): 
100          tree = self.parse('<a><b/></a>') 
101          a = tree.getroot() 
102          b = a[0] 
103   
104          xml_out = self._saxify_serialize(a) 
105          self.assertEqual(_bytes('<a><b/></a>'), 
106                            xml_out) 
107   
108          xml_out = self._saxify_serialize(b) 
109          self.assertEqual(_bytes('<b/>'), 
110                            xml_out) 
111   
112 -    def test_element_sax_ns(self): 
113          tree = self.parse('<a:a xmlns:a="blaA"><b/></a:a>') 
114          a = tree.getroot() 
115          b = a[0] 
116   
117          new_tree = self._saxify_unsaxify(a) 
118          root = new_tree.getroot() 
119          self.assertEqual('{blaA}a', 
120                           root.tag) 
121          self.assertEqual('b', 
122                           root[0].tag) 
123   
124          new_tree = self._saxify_unsaxify(b) 
125          root = new_tree.getroot() 
126          self.assertEqual('b', 
127                           root.tag) 
128          self.assertEqual(0, 
129                           len(root)) 
130   
131 -    def test_etree_sax_handler_default_ns(self): 
132          handler = sax.ElementTreeContentHandler() 
133          handler.startDocument() 
134          handler.startPrefixMapping(None, 'blaA') 
135          handler.startElementNS(('blaA', 'a'), 'a', {}) 
136          handler.startPrefixMapping(None, 'blaB') 
137          handler.startElementNS(('blaB', 'b'), 'b', {}) 
138          handler.endElementNS(  ('blaB', 'b'), 'b') 
139          handler.endPrefixMapping(None) 
140          handler.startElementNS(('blaA', 'c'), 'c', {}) 
141          handler.endElementNS(  ('blaA', 'c'), 'c') 
142          handler.endElementNS(  ('blaA', 'a'), 'a') 
143          handler.endPrefixMapping(None) 
144          handler.endDocument() 
145   
146          new_tree = handler.etree 
147          root = new_tree.getroot() 
148          self.assertEqual('{blaA}a', 
149                           root.tag) 
150          self.assertEqual('{blaB}b', 
151                           root[0].tag) 
152          self.assertEqual('{blaA}c', 
153                           root[1].tag) 
154   
155 -    def test_etree_sax_handler_default_ns_None(self): 
156          handler = sax.ElementTreeContentHandler() 
157          handler.startDocument() 
158          handler.startPrefixMapping(None, 'blaA') 
159          handler.startElementNS((None, 'a'), 'a', {}) 
160          handler.startPrefixMapping(None, 'blaB') 
161          handler.startElementNS((None, 'b'), 'b', {}) 
162          handler.endElementNS(  (None, 'b'), 'b') 
163          handler.endPrefixMapping(None) 
164          handler.startElementNS((None, 'c'), 'c', {}) 
165          handler.endElementNS(  (None, 'c'), 'c') 
166          handler.endElementNS(  (None, 'a'), 'a') 
167          handler.endPrefixMapping(None) 
168          handler.endDocument() 
169   
170          new_tree = handler.etree 
171          root = new_tree.getroot() 
172          self.assertEqual('{blaA}a', 
173                           root.tag) 
174          self.assertEqual('{blaB}b', 
175                           root[0].tag) 
176          self.assertEqual('{blaA}c', 
177                           root[1].tag) 
178   
179 -    def test_etree_sax_redefine_ns(self): 
180          handler = sax.ElementTreeContentHandler() 
181          handler.startDocument() 
182          handler.startPrefixMapping('ns', 'blaA') 
183          handler.startElementNS(('blaA', 'a'), 'ns:a', {}) 
184          handler.startPrefixMapping('ns', 'blaB') 
185          handler.startElementNS(('blaB', 'b'), 'ns:b', {}) 
186          handler.endElementNS(  ('blaB', 'b'), 'ns:b') 
187          handler.endPrefixMapping('ns') 
188          handler.startElementNS(('blaA', 'c'), 'ns:c', {}) 
189          handler.endElementNS(  ('blaA', 'c'), 'ns:c') 
190          handler.endElementNS(  ('blaA', 'a'), 'ns:a') 
191          handler.endPrefixMapping('ns') 
192          handler.endDocument() 
193   
194          new_tree = handler.etree 
195          root = new_tree.getroot() 
196          self.assertEqual('{blaA}a', 
197                           root.tag) 
198          self.assertEqual('{blaB}b', 
199                           root[0].tag) 
200          self.assertEqual('{blaA}c', 
201                           root[1].tag) 
202   
203 -    def test_etree_sax_no_ns(self): 
204          handler = sax.ElementTreeContentHandler() 
205          handler.startDocument() 
206          handler.startElement('a', {}) 
207          handler.startElement('b', {}) 
208          handler.endElement('b') 
209          handler.startElement('c') # with empty attributes 
210          handler.endElement('c') 
211          handler.endElement('a') 
212          handler.endDocument() 
213   
214          new_tree = handler.etree 
215          root = new_tree.getroot() 
216          self.assertEqual('a', root.tag) 
217          self.assertEqual('b', root[0].tag) 
218          self.assertEqual('c', root[1].tag) 
219   
220 -    def test_etree_sax_no_ns_attributes(self): 
221          handler = sax.ElementTreeContentHandler() 
222          handler.startDocument() 
223          handler.startElement('a', {"attr_a1": "a1"}) 
224          handler.startElement('b', {"attr_b1": "b1"}) 
225          handler.endElement('b') 
226          handler.endElement('a') 
227          handler.endDocument() 
228   
229          new_tree = handler.etree 
230          root = new_tree.getroot() 
231          self.assertEqual('a', root.tag) 
232          self.assertEqual('b', root[0].tag) 
233          self.assertEqual('a1', root.attrib["attr_a1"]) 
234          self.assertEqual('b1', root[0].attrib["attr_b1"]) 
235   
236 -    def test_etree_sax_ns_attributes(self): 
237          handler = sax.ElementTreeContentHandler() 
238          handler.startDocument() 
239   
240          self.assertRaises(ValueError, 
241              handler.startElement, 
242              'a', {"blaA:attr_a1": "a1"} 
243          ) 
244   
245 -    def test_etree_sax_error(self): 
246          handler = sax.ElementTreeContentHandler() 
247          handler.startDocument() 
248          handler.startElement('a') 
249          self.assertRaises(sax.SaxError, handler.endElement, 'b') 
250   
251 -    def test_etree_sax_error2(self): 
252          handler = sax.ElementTreeContentHandler() 
253          handler.startDocument() 
254          handler.startElement('a') 
255          handler.startElement('b') 
256          self.assertRaises(sax.SaxError, handler.endElement, 'a') 
257   
258 -    def _saxify_unsaxify(self, saxifiable): 
259          handler = sax.ElementTreeContentHandler() 
260          sax.ElementTreeProducer(saxifiable, handler).saxify() 
261          return handler.etree 
262   
263 -    def _saxify_serialize(self, tree): 
264          new_tree = self._saxify_unsaxify(tree) 
265          f = BytesIO() 
266          new_tree.write(f) 
267          return f.getvalue().replace(_bytes('\n'), _bytes('')) 
268   
269   
270 -def test_suite(): 
271      suite = unittest.TestSuite() 
272      suite.addTests([unittest.makeSuite(ETreeSaxTestCase)]) 
273      suite.addTests( 
274          [make_doctest('../../../doc/sax.txt')]) 
275      return suite 
276   
277   
278  if __name__ == '__main__': 
279      print('to test use test.py %s' % __file__) 
280